CSSValue Immediates: Change CSSValue to an object instead of a pointer

Source/core/css/parser/CSSPropertyParser.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 107 matching lines @@
     // This doesn't count UA style sheets
     if (parseSuccess && context.useCounter())
         context.useCounter()->count(context, unresolvedProperty);
 
     if (!parseSuccess)
         parser.rollbackLastProperties(parsedProperties.size() - parsedPropertiesSize);
 
     return parseSuccess;
 }
 
-void CSSPropertyParser::addProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<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);
         // Viewport descriptors have width and height as shorthands, but it doesn't
@@ skipping 171 matching lines @@
     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
 }
 
 inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_CUSTOM_IDENT);
 }
 
-inline PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
+inline CSSValue CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
 {
-    RefPtrWillBeRawPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);
-    toCSSImageValue(imageValue.get())->setReferrer(m_context.referrer());
+    CSSValue imageValue = CSSImageValue::create(rawValue, url);
+    toCSSImageValue(imageValue).setReferrer(m_context.referrer());
     return imageValue;
 }
 
 static inline bool isComma(CSSParserValue* value)
 {
     ASSERT(value);
     return value->unit == CSSParserValue::Operator && value->iValue == ',';
 }
 
 static bool consumeComma(CSSParserValueList* valueList)
@@ skipping 58 matching lines @@
     if (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSParserValue::Q_EMS)
         return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
     if (isCalculation(value))
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
 
     return nullptr;
 }
 
-void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> prpValue, bool important)
+void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, CSSValue prpValue, bool important)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     unsigned shorthandLength = shorthand.length();
     if (!shorthandLength) {
         addProperty(propId, prpValue, important);
         return;
     }
 
-    RefPtrWillBeRawPtr<CSSValue> value = prpValue;
+    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::parseValue(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID propId = resolveCSSPropertyID(unresolvedProperty);
 
@@ skipping 28 matching lines @@
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
     bool validPrimitive = false;
     Units unitless = FUnknown;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+    NullableCSSValue parsedValue;
 
     switch (propId) {
     case CSSPropertySize: // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
         parsedValue = parseSize();
         break;
     case CSSPropertyQuotes: // [<string> <string>]+ | none
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseQuotes();
@@ skipping 11 matching lines @@
         break;
 
     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
      * correctly and allows optimization in blink::applyRule(..)
      */
     case CSSPropertyOverflow: {
         ShorthandScope scope(this, propId);
         if (num != 1 || !parseValue(CSSPropertyOverflowY, important))
             return false;
 
-        RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;
-
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
+        NullableCSSValue overflowXValue;
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = m_parsedProperties.last().value();
-        addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
+        addProperty(CSSPropertyOverflowX, *overflowXValue, important);
         return true;
     }
 
     case CSSPropertyTextAlign:
         // left | right | center | justify | -webkit-left | -webkit-right | -webkit-center | -webkit-match-parent
         // | start | end | <string> | inherit | -webkit-auto (converted to start)
         // FIXME: <string> not supported right now
         if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd) {
             validPrimitive = true;
         }
         break;
 
     case CSSPropertyFontWeight:  { // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
         if (m_valueList->size() != 1)
             return false;
         return parseFontWeight(important);
     }
 
     case CSSPropertyBorderSpacing: {
         if (num == 1) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
                 return false;
-            CSSValue* value = m_parsedProperties.last().value();
+            CSSValue value = m_parsedProperties.last().value();
             addProperty(CSSPropertyWebkitBorderVerticalSpacing, value, important);
             return true;
         }
         else if (num == 2) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important) || !parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))
                 return false;
             return true;
         }
         return false;
@@ skipping 65 matching lines @@
     case CSSPropertyCursor: {
         // Grammar defined by CSS3 UI and modified by CSS4 images:
         // [ [<image> [<x> <y>]?,]*
         // [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | all-scroll |
         // zoom-in | zoom-out | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out ] ] | inherit
         RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
         while (value) {
-            RefPtrWillBeRawPtr<CSSValue> image = nullptr;
+            NullableCSSValue image;
             if (value->unit == CSSPrimitiveValue::CSS_URI) {
                 String uri = value->string;
                 if (!uri.isNull())
                     image = createCSSImageValueWithReferrer(uri, completeURL(uri));
             } else if (value->unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {
                 image = parseImageSet(m_valueList);
                 if (!image)
                     break;
             } else
                 break;
@@ skipping 11 matching lines @@
                 return false;
             if (nrcoords == 2) {
                 hotSpotSpecified = true;
                 hotSpot = IntPoint(coords[0], coords[1]);
             }
 
             if (!list)
                 list = CSSValueList::createCommaSeparated();
 
             if (image)
-                list->append(CSSCursorImageValue::create(image, hotSpotSpecified, hotSpot));
+                list->append(CSSCursorImageValue::create(*image, hotSpotSpecified, hotSpot));
 
             if (!consumeComma(m_valueList))
                 return false;
             value = m_valueList->current();
         }
         if (value && m_context.useCounter()) {
             if (value->id == CSSValueWebkitZoomIn)
                 m_context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);
             else if (value->id == CSSValueWebkitZoomOut)
                 m_context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
@@ skipping 41 matching lines @@
     case CSSPropertyWebkitMaskImage:
     case CSSPropertyWebkitMaskOrigin:
     case CSSPropertyWebkitMaskPosition:
     case CSSPropertyWebkitMaskPositionX:
     case CSSPropertyWebkitMaskPositionY:
     case CSSPropertyWebkitMaskSize:
     case CSSPropertyWebkitMaskRepeat:
     case CSSPropertyWebkitMaskRepeatX:
     case CSSPropertyWebkitMaskRepeatY:
     {
-        RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
-        RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
+        NullableCSSValue val1;
+        NullableCSSValue val2;
         CSSPropertyID propId1, propId2;
         bool result = false;
         if (parseFillProperty(unresolvedProperty, propId1, propId2, val1, val2)) {
             if (propId == CSSPropertyBackgroundPosition ||
                 propId == CSSPropertyBackgroundRepeat ||
                 propId == CSSPropertyWebkitMaskPosition ||
                 propId == CSSPropertyWebkitMaskRepeat) {
                 ShorthandScope scope(this, propId);
-                addProperty(propId1, val1.release(), important);
+                addProperty(propId1, *val1, important);
                 if (val2)
-                    addProperty(propId2, val2.release(), important);
+                    addProperty(propId2, *val2, important);
             } else {
-                addProperty(propId1, val1.release(), important);
+                addProperty(propId1, *val1, important);
                 if (val2)
-                    addProperty(propId2, val2.release(), important);
+                    addProperty(propId2, *val2, important);
             }
             result = true;
         }
         m_implicitShorthand = false;
         return result;
     }
     case CSSPropertyObjectPosition:
         parsedValue = parsePosition(m_valueList);
         break;
     case CSSPropertyListStyleImage:     // <uri> | none | inherit
@@ skipping 192 matching lines @@
     case CSSPropertyUnicodeRange:
         /* @font-face only descriptors */
         break;
 
     /* CSS3 properties */
 
     case CSSPropertyBorderImage:
     case CSSPropertyWebkitMaskBoxImage:
         return parseBorderImageShorthand(propId, important);
     case CSSPropertyWebkitBorderImage: {
-        if (RefPtrWillBeRawPtr<CSSValue> result = parseBorderImage(propId)) {
-            addProperty(propId, result, important);
+        if (NullableCSSValue result = parseBorderImage(propId)) {
+            addProperty(propId, *result, important);
             return true;
         }
         return false;
     }
 
     case CSSPropertyBorderImageOutset:
     case CSSPropertyWebkitMaskBoxImageOutset: {
         RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageRepeat:
     case CSSPropertyWebkitMaskBoxImageRepeat: {
-        RefPtrWillBeRawPtr<CSSValue> result = nullptr;
+        NullableCSSValue result;
         if (parseBorderImageRepeat(result)) {
-            addProperty(propId, result, important);
+            addProperty(propId, *result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageSlice:
     case CSSPropertyWebkitMaskBoxImageSlice: {
         RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
             addProperty(propId, result, important);
             return true;
@@ skipping 73 matching lines @@
     case CSSPropertyWebkitBoxFlexGroup:
         validPrimitive = validUnit(value, FInteger | FNonNeg);
         break;
     case CSSPropertyWebkitBoxOrdinalGroup:
         validPrimitive = validUnit(value, FInteger | FNonNeg) && value->fValue;
         break;
     case CSSPropertyWebkitFilter:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
-            RefPtrWillBeRawPtr<CSSValue> val = parseFilter();
+            NullableCSSValue val = parseFilter();
             if (val) {
-                addProperty(propId, val, important);
+                addProperty(propId, *val, important);
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyFlex: {
         ShorthandScope scope(this, propId);
         if (id == CSSValueNone) {
             addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER), important);
             addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER), important);
@@ skipping 165 matching lines @@
 
     case CSSPropertyGrid:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return parseGridShorthand(important);
 
     case CSSPropertyWebkitMarginCollapse: {
         if (num == 1) {
             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
             if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))
                 return false;
-            CSSValue* value = m_parsedProperties.last().value();
+            CSSValue value = m_parsedProperties.last().value();
             addProperty(webkitMarginCollapseShorthand().properties()[1], value, important);
             return true;
         }
         else if (num == 2) {
             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
             if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important) || !parseValue(webkitMarginCollapseShorthand().properties()[1], important))
                 return false;
             return true;
         }
         return false;
@@ skipping 190 matching lines @@
         else
             return parseFontVariantLigatures(important);
         break;
     case CSSPropertyWebkitClipPath:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (value->unit == CSSParserValue::Function) {
             parsedValue = parseBasicShape();
         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
             parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, *parsedValue, important);
             return true;
         }
         break;
     case CSSPropertyShapeOutside:
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseShapeProperty(propId);
         break;
     case CSSPropertyShapeMargin:
@@ skipping 51 matching lines @@
         return parseSVGValue(propId, important);
     }
 
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, *parsedValue, important);
             return true;
         }
     }
     return false;
 }
 
-void CSSPropertyParser::addFillValue(RefPtrWillBeRawPtr<CSSValue>& lval, PassRefPtrWillBeRawPtr<CSSValue> rval)
+void CSSPropertyParser::addFillValue(NullableCSSValue& lval, CSSValue rval)
 {
     if (lval) {
         if (lval->isBaseValueList())
-            toCSSValueList(lval.get())->append(rval);
+            toCSSValueList(lval)->append(rval);
         else {
-            PassRefPtrWillBeRawPtr<CSSValue> oldlVal(lval.release());
             PassRefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
-            list->append(oldlVal);
+            list->append(*lval);
             list->append(rval);
             lval = list;
         }
     }
     else
         lval = rval;
 }
 
-static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtrWillBeRawPtr<CSSValue>& cssValue)
+static bool parseBackgroundClip(CSSParserValue* parserValue, NullableCSSValue& cssValue)
 {
     if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
         || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {
         cssValue = cssValuePool().createIdentifierValue(parserValue->id);
         return true;
     }
     return false;
 }
 
 const int cMaxFillProperties = 9;
 
 bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)
 {
     ASSERT(numProperties <= cMaxFillProperties);
     if (numProperties > cMaxFillProperties)
         return false;
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[cMaxFillProperties] = { false };
-    RefPtrWillBeRawPtr<CSSValue> values[cMaxFillProperties];
+    NullableCSSValue values[cMaxFillProperties];
 #if ENABLE(OILPAN)
     // Zero initialize the array of raw pointers.
     memset(&values, 0, sizeof(values));
 #endif
-    RefPtrWillBeRawPtr<CSSValue> clipValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> positionYValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> repeatYValue = nullptr;
+    NullableCSSValue clipValue;
+    NullableCSSValue positionYValue;
+    NullableCSSValue repeatYValue;
     bool foundClip = false;
     int i;
     bool foundPositionCSSProperty = false;
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (isComma(val)) {
             // We hit the end.  Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
@@ skipping 28 matching lines @@
         foundPositionCSSProperty = false;
         bool found = false;
         for (i = 0; !found && i < numProperties; ++i) {
 
             if (sizeCSSPropertyExpected && (properties[i] != CSSPropertyBackgroundSize && properties[i] != CSSPropertyWebkitMaskSize))
                 continue;
             if (!sizeCSSPropertyExpected && (properties[i] == CSSPropertyBackgroundSize || properties[i] == CSSPropertyWebkitMaskSize))
                 continue;
 
             if (!parsedProperty[i]) {
-                RefPtrWillBeRawPtr<CSSValue> val1 = nullptr;
-                RefPtrWillBeRawPtr<CSSValue> val2 = nullptr;
+                NullableCSSValue val1;
+                NullableCSSValue val2;
                 CSSPropertyID propId1, propId2;
                 CSSParserValue* parserValue = m_valueList->current();
                 // parseFillProperty() may modify m_implicitShorthand, so we MUST reset it
                 // before EACH return below.
                 if (parserValue && parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
                     parsedProperty[i] = found = true;
-                    addFillValue(values[i], val1.release());
+                    addFillValue(values[i], *val1);
                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
-                        addFillValue(positionYValue, val2.release());
+                        addFillValue(positionYValue, *val2);
                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
-                        addFillValue(repeatYValue, val2.release());
+                        addFillValue(repeatYValue, *val2);
                     if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
                         // Reparse the value as a clip, and see if we succeed.
                         if (parseBackgroundClip(parserValue, val1))
-                            addFillValue(clipValue, val1.release()); // The property parsed successfully.
+                            addFillValue(clipValue, *val1); // The property parsed successfully.
                         else
                             addFillValue(clipValue, cssValuePool().createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead.
                     }
                     if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) {
                         // Update clipValue
-                        addFillValue(clipValue, val1.release());
+                        addFillValue(clipValue, *val1);
                         foundClip = true;
                     }
                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
                         foundPositionCSSProperty = true;
                 }
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
@@ skipping 11 matching lines @@
             if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
                 addFillValue(positionYValue, cssValuePool().createImplicitInitialValue());
             if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
                 addFillValue(repeatYValue, cssValuePool().createImplicitInitialValue());
             if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
                 // If background-origin wasn't present, then reset background-clip also.
                 addFillValue(clipValue, cssValuePool().createImplicitInitialValue());
             }
         }
         if (properties[i] == CSSPropertyBackgroundPosition) {
-            addProperty(CSSPropertyBackgroundPositionX, values[i].release(), important);
+            addProperty(CSSPropertyBackgroundPositionX, *values[i], important);
             // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyBackgroundPositionY, positionYValue.release(), important);
+            addProperty(CSSPropertyBackgroundPositionY, *positionYValue, important);
         } else if (properties[i] == CSSPropertyWebkitMaskPosition) {
-            addProperty(CSSPropertyWebkitMaskPositionX, values[i].release(), important);
+            addProperty(CSSPropertyWebkitMaskPositionX, *values[i], important);
             // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once
-            addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskPositionY, *positionYValue, important);
         } else if (properties[i] == CSSPropertyBackgroundRepeat) {
-            addProperty(CSSPropertyBackgroundRepeatX, values[i].release(), important);
+            addProperty(CSSPropertyBackgroundRepeatX, *values[i], important);
             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release(), important);
+            addProperty(CSSPropertyBackgroundRepeatY, *repeatYValue, important);
         } else if (properties[i] == CSSPropertyWebkitMaskRepeat) {
-            addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release(), important);
+            addProperty(CSSPropertyWebkitMaskRepeatX, *values[i], important);
             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskRepeatY, *repeatYValue, important);
         } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip)
             // Value is already set while updating origin
             continue;
         else if (properties[i] == CSSPropertyBackgroundSize && !parsedProperty[i] && m_context.useLegacyBackgroundSizeShorthandBehavior())
             continue;
         else
-            addProperty(properties[i], values[i].release(), important);
+            addProperty(properties[i], *values[i], important);
 
         // Add in clip values when we hit the corresponding origin property.
         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
-            addProperty(CSSPropertyBackgroundClip, clipValue.release(), important);
+            addProperty(CSSPropertyBackgroundClip, *clipValue, important);
         else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
-            addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskClip, *clipValue, important);
     }
 
     m_implicitShorthand = false;
     return true;
 }
 
 static bool isValidTransitionPropertyList(CSSValueList* value)
 {
     if (value->length() < 2)
         return true;
     for (auto& property : *value) {
         // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
-        if (property->isInitialValue())
+        if (property.isInitialValue())
             continue;
-        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(property.get());
-        if (primitiveValue->isValueID() && primitiveValue->getValueID() == CSSValueNone)
+        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(property);
+        if (primitiveValue.isValueID() && primitiveValue.getValueID() == CSSValueNone)
             return false;
     }
     return true;
 }
 
 bool CSSPropertyParser::parseAnimationShorthand(bool useLegacyparsing, bool important)
 {
     const StylePropertyShorthand& animationProperties = animationShorthandForParsing();
     const unsigned numProperties = 8;
 
@@ skipping 19 matching lines @@
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
         }
 
         bool found = false;
         for (size_t i = 0; i < numProperties; ++i) {
             if (parsedProperty[i])
                 continue;
-            if (RefPtrWillBeRawPtr<CSSValue> val = parseAnimationProperty(animationProperties.properties()[i], useLegacyparsing)) {
+            if (NullableCSSValue val = parseAnimationProperty(animationProperties.properties()[i], useLegacyparsing)) {
                 parsedProperty[i] = found = true;
-                values[i]->append(val.release());
+                values[i]->append(*val);
                 break;
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
@@ skipping 30 matching lines @@
                 parsedProperty[i] = false;
             }
             if (!m_valueList->current())
                 break;
         }
 
         bool found = false;
         for (size_t i = 0; i < numProperties; ++i) {
             if (parsedProperty[i])
                 continue;
-            if (RefPtrWillBeRawPtr<CSSValue> val = parseAnimationProperty(shorthand.properties()[i], false)) {
+            if (NullableCSSValue val = parseAnimationProperty(shorthand.properties()[i], false)) {
                 parsedProperty[i] = found = true;
-                values[i]->append(val.release());
+                values[i]->append(*val);
                 break;
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
     ASSERT(shorthand.properties()[3] == CSSPropertyTransitionProperty);
     if (!isValidTransitionPropertyList(values[3].get()))
         return false;
 
     // Fill in any remaining properties with the initial value and add
     for (size_t i = 0; i < numProperties; ++i) {
         if (!parsedProperty[i])
             values[i]->append(cssValuePool().createImplicitInitialValue());
         addProperty(shorthand.properties()[i], values[i].release(), important);
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColumnWidth()
+NullableCSSValue CSSPropertyParser::parseColumnWidth()
 {
     CSSParserValue* value = m_valueList->current();
     // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
     // the 'columns' shorthand property.
     if (value->id == CSSValueAuto || (validUnit(value, FLength | FNonNeg, HTMLStandardMode) && (m_parsedCalculation || value->fValue != 0))) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
+        CSSValue parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColumnCount()
+NullableCSSValue CSSPropertyParser::parseColumnCount()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto || validUnit(value, FPositiveInteger)) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
+        CSSValue parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
     return nullptr;
 }
 
 bool CSSPropertyParser::parseColumnsShorthand(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValue> columnWidth = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> columnCount = nullptr;
+    NullableCSSValue columnWidth;
+    NullableCSSValue columnCount;
     bool hasPendingExplicitAuto = false;
 
     for (unsigned propertiesParsed = 0; CSSParserValue* value = m_valueList->current(); propertiesParsed++) {
         if (propertiesParsed >= 2)
             return false; // Too many values for this shorthand. Invalid declaration.
         if (!propertiesParsed && value->id == CSSValueAuto) {
             // 'auto' is a valid value for any of the two longhands, and at this point we
             // don't know which one(s) it is meant for. We need to see if there are other
             // values first.
             m_valueList->next();
@@ skipping 21 matching lines @@
             columnWidth = cssValuePool().createIdentifierValue(CSSValueAuto);
         } else {
             ASSERT(!columnCount);
             columnCount = cssValuePool().createIdentifierValue(CSSValueAuto);
         }
     }
     ASSERT(columnCount || columnWidth);
 
     // Any unassigned property at this point will become implicit 'auto'.
     if (columnWidth)
-        addProperty(CSSPropertyWebkitColumnWidth, columnWidth, important);
+        addProperty(CSSPropertyWebkitColumnWidth, *columnWidth, important);
     else
         addProperty(CSSPropertyWebkitColumnWidth, cssValuePool().createIdentifierValue(CSSValueAuto), important, true /* implicit */);
     if (columnCount)
-        addProperty(CSSPropertyWebkitColumnCount, columnCount, important);
+        addProperty(CSSPropertyWebkitColumnCount, *columnCount, important);
     else
         addProperty(CSSPropertyWebkitColumnCount, cssValuePool().createIdentifierValue(CSSValueAuto), important, true /* implicit */);
     return true;
 }
 
 bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, const StylePropertyShorthand& shorthand, bool important)
 {
     // We try to match as many properties as possible
     // We set up an array of booleans to mark which property has been found,
     // and we try to search for properties until it makes no longer any sense.
@@ skipping 51 matching lines @@
 
     int num = inShorthand() ? 1 : m_valueList->size();
 
     ShorthandScope scope(this, propId);
 
     // the order is top, right, bottom, left
     switch (num) {
         case 1: {
             if (!parseValue(properties[0], important))
                 return false;
-            CSSValue* value = m_parsedProperties.last().value();
+            CSSValue value = m_parsedProperties.last().value();
             ImplicitScope implicitScope(this);
             addProperty(properties[1], value, important);
             addProperty(properties[2], value, important);
             addProperty(properties[3], value, important);
             break;
         }
         case 2: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
                 return false;
-            CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
+            CSSValue value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
             addProperty(properties[2], value, important);
             value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             addProperty(properties[3], value, important);
             break;
         }
         case 3: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
                 return false;
-            CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
+            CSSValue value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
             addProperty(properties[3], value, important);
             break;
         }
         case 4: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
                 return false;
             break;
         }
         default: {
             return false;
         }
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapPoints()
+NullableCSSValue CSSPropertyParser::parseScrollSnapPoints()
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     if (value->unit == CSSParserValue::Function && value->function->id == CSSValueRepeat) {
         // The spec defines the following grammar: repeat( <length>)
         CSSParserValueList* arguments = value->function->args.get();
         if (!arguments || arguments->size() != 1)
             return nullptr;
 
         CSSParserValue* repeatValue = arguments->valueAt(0);
         if (!validUnit(repeatValue, FNonNeg | FLength | FPercent))
             return nullptr;
 
         RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
         result->append(parseValidPrimitive(repeatValue->id, repeatValue));
         m_valueList->next();
         return result.release();
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
+NullableCSSValue CSSPropertyParser::parseScrollSnapCoordinate()
 {
     if (m_valueList->current()->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     return parsePositionList(m_valueList);
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parsePage()
@@ skipping 69 matching lines @@
             parsedValues->append(createPrimitiveNumericValue(value));
             return Length;
         }
         return None;
     default:
         return None;
     }
 }
 
 // [ <string> <string> ]+ | none, but none is handled in parseValue
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseQuotes()
+NullableCSSValue CSSPropertyParser::parseQuotes()
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+        NullableCSSValue parsedValue;
         if (val->unit != CSSPrimitiveValue::CSS_STRING)
             return nullptr;
         parsedValue = createPrimitiveStringValue(val);
-        values->append(parsedValue.release());
+        values->append(*parsedValue);
         m_valueList->next();
     }
     if (values->length() && values->length() % 2 == 0)
         return values.release();
     return nullptr;
 }
 
 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
 // in CSS 2.1 this got somewhat reduced:
 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseContent()
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
 
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+        NullableCSSValue parsedValue;
         if (val->unit == CSSPrimitiveValue::CSS_URI) {
             // url
             parsedValue = createCSSImageValueWithReferrer(val->string, completeURL(val->string));
         } else if (val->unit == CSSParserValue::Function) {
             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
             CSSParserValueList* args = val->function->args.get();
             if (!args)
                 return nullptr;
             if (val->function->id == CSSValueAttr) {
                 parsedValue = parseAttr(args);
@@ skipping 17 matching lines @@
             case CSSValueNormal:
                 parsedValue = cssValuePool().createIdentifierValue(val->id);
             default:
                 break;
             }
         } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
             parsedValue = createPrimitiveStringValue(val);
         }
         if (!parsedValue)
             return nullptr;
-        values->append(parsedValue.release());
+        values->append(*parsedValue);
         m_valueList->next();
     }
 
     return values.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAttr(CSSParserValueList* args)
+NullableCSSValue CSSPropertyParser::parseAttr(CSSParserValueList* args)
 {
     if (args->size() != 1)
         return nullptr;
 
     CSSParserValue* a = args->current();
 
     if (a->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
 
     String attrName = a->string;
     // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
     // But HTML attribute names can't have those characters, and we should not
     // even parse them inside attr().
     if (attrName[0] == '-')
         return nullptr;
 
     if (m_context.isHTMLDocument())
         attrName = attrName.lower();
 
     return cssValuePool().createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBackgroundColor()
+NullableCSSValue CSSPropertyParser::parseBackgroundColor()
 {
     CSSValueID id = m_valueList->current()->id;
     if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor ||
         (id >= CSSValueGrey && id < CSSValueWebkitText && inQuirksMode()))
         return cssValuePool().createIdentifierValue(id);
     return parseColor();
 }
 
-bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value)
+bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, NullableCSSValue& value)
 {
     if (valueList->current()->id == CSSValueNone) {
         value = cssValuePool().createIdentifierValue(CSSValueNone);
         return true;
     }
     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
         value = createCSSImageValueWithReferrer(valueList->current()->string, completeURL(valueList->current()->string));
         return true;
     }
 
     if (isGeneratedImageValue(valueList->current()))
         return parseGeneratedImage(valueList, value);
 
     if (valueList->current()->unit == CSSParserValue::Function && valueList->current()->function->id == CSSValueWebkitImageSet) {
         value = parseImageSet(m_valueList);
         if (value)
             return true;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionX(CSSParserValueList* valueList)
+NullableCSSValue CSSPropertyParser::parseFillPositionX(CSSParserValueList* valueList)
 {
     int id = valueList->current()->id;
     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueRight)
             percent = 100;
         else if (id == CSSValueCenter)
             percent = 50;
         return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
     }
     if (validUnit(valueList->current(), FPercent | FLength))
         return createPrimitiveNumericValue(valueList->current());
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionY(CSSParserValueList* valueList)
+NullableCSSValue CSSPropertyParser::parseFillPositionY(CSSParserValueList* valueList)
 {
     int id = valueList->current()->id;
     if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueBottom)
             percent = 100;
         else if (id == CSSValueCenter)
             percent = 50;
         return cssValuePool().createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
     }
@@ skipping 60 matching lines @@
         return true;
 
     return false;
 }
 
 static bool isFillPositionKeyword(CSSValueID value)
 {
     return value == CSSValueLeft || value == CSSValueTop || value == CSSValueBottom || value == CSSValueRight || value == CSSValueCenter;
 }
 
-void CSSPropertyParser::parse4ValuesFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2)
+void CSSPropertyParser::parse4ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2)
 {
     // [ left | right ] [ <percentage] | <length> ] && [ top | bottom ] [ <percentage> | <length> ]
     // In the case of 4 values <position> requires the second value to be a length or a percentage.
     if (isFillPositionKeyword(parsedValue2->getValueID()))
         return;
 
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
     if (!value3)
@@ skipping 27 matching lines @@
         return;
 
     value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
     value2 = createPrimitiveValuePair(value3, value4);
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom)
         value1.swap(value2);
 
     valueList->next();
 }
-void CSSPropertyParser::parse3ValuesFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2)
+void CSSPropertyParser::parse3ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2)
 {
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
 
     // value3 is not an expected value, we return.
     if (!value3)
         return;
 
     valueList->next();
@@ skipping 61 matching lines @@
             return;
 
         value1 = createPrimitiveValuePair(parsedValue1, firstPositionValue);
         value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), secondPositionValue);
     }
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom || swapNeeded)
         value1.swap(value2);
 
 #if ENABLE(ASSERT)
-    CSSPrimitiveValue* first = toCSSPrimitiveValue(value1.get());
-    CSSPrimitiveValue* second = toCSSPrimitiveValue(value2.get());
+    CSSPrimitiveValue* first = toCSSPrimitiveValue(value1);
+    CSSPrimitiveValue* second = toCSSPrimitiveValue(value2);
     ident1 = first->getPairValue()->first()->getValueID();
     ident2 = second->getPairValue()->first()->getValueID();
     ASSERT(ident1 == CSSValueLeft || ident1 == CSSValueRight);
     ASSERT(ident2 == CSSValueBottom || ident2 == CSSValueTop);
 #endif
 }
 
 inline bool CSSPropertyParser::isPotentialPositionValue(CSSParserValue* value)
 {
     return isFillPositionKeyword(value->id) || validUnit(value, FPercent | FLength, ReleaseParsedCalcValue);
 }
 
-void CSSPropertyParser::parseFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, Units unitless)
+void CSSPropertyParser::parseFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, Units unitless)
 {
     unsigned numberOfValues = 0;
     for (unsigned i = valueList->currentIndex(); i < valueList->size(); ++i, ++numberOfValues) {
         CSSParserValue* current = valueList->valueAt(i);
         if (!current || isComma(current) || isForwardSlashOperator(current) || !isPotentialPositionValue(current))
             break;
     }
 
     if (numberOfValues > 4)
         return;
@@ skipping 22 matching lines @@
 
     valueList->next();
 
     // In case we are parsing more than two values, relax the check inside of parseFillPositionComponent. top 20px is
     // a valid start for <position>.
     cumulativeFlags = AmbiguousFillPosition;
     value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag, ResolveValuesAsKeyword);
     if (value2)
         valueList->next();
     else {
-        value1.clear();
+        value1 = nullptr;
         return;
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = toCSSPrimitiveValue(value1.get());
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = toCSSPrimitiveValue(value2.get());
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = toCSSPrimitiveValue(value1);
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = toCSSPrimitiveValue(value2);
 
-    value1.clear();
-    value2.clear();
+    value1 = nullptr;
+    value2 = nullptr;
 
     // Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.
     if (parsedValue2->getValueID() == CSSValueCenter)
         return;
 
     if (numberOfValues == 3)
-        parse3ValuesFillPosition(valueList, value1, value2, parsedValue1.release(), parsedValue2.release());
+        parse3ValuesFillPosition(valueList, value1, value2, parsedValue1, parsedValue2);
     else
-        parse4ValuesFillPosition(valueList, value1, value2, parsedValue1.release(), parsedValue2.release());
+        parse4ValuesFillPosition(valueList, value1, value2, parsedValue1, parsedValue2);
 }
 
-void CSSPropertyParser::parse2ValuesFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, Units unitless)
+void CSSPropertyParser::parse2ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, Units unitless)
 {
     // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
     unsigned cumulativeFlags = 0;
     FillPositionFlag value1Flag = InvalidFillPosition;
     FillPositionFlag value2Flag = InvalidFillPosition;
     value1 = parseFillPositionComponent(valueList, cumulativeFlags, value1Flag, ResolveValuesAsPercent, unitless);
     if (!value1)
         return;
 
     // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
     // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
     // value was explicitly specified for our property.
     CSSParserValue* value = valueList->next();
 
     // First check for the comma.  If so, we are finished parsing this value or value pair.
     if (value && isComma(value))
         value = 0;
 
     if (value) {
         value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag, ResolveValuesAsPercent, unitless);
         if (value2)
             valueList->next();
         else {
             if (!inShorthand()) {
-                value1.clear();
+                value1 = nullptr;
                 return;
             }
         }
     }
 
     if (!value2)
         // Only one value was specified. If that value was not a keyword, then it sets the x position, and the y position
         // is simply 50%. This is our default.
         // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
         // For left/right/center, the default of 50% in the y is still correct.
         value2 = cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
 
     if (value1Flag == YFillPosition || value2Flag == XFillPosition)
         value1.swap(value2);
 }
 
-void CSSPropertyParser::parseFillRepeat(RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2)
+void CSSPropertyParser::parseFillRepeat(NullableCSSValue& value1, NullableCSSValue& value2)
 {
     CSSValueID id = m_valueList->current()->id;
     if (id == CSSValueRepeatX) {
         m_implicitShorthand = true;
         value1 = cssValuePool().createIdentifierValue(CSSValueRepeat);
         value2 = cssValuePool().createIdentifierValue(CSSValueNoRepeat);
         m_valueList->next();
         return;
     }
     if (id == CSSValueRepeatY) {
@@ skipping 17 matching lines @@
         id = value->id;
         if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace) {
             value2 = cssValuePool().createIdentifierValue(id);
             m_valueList->next();
             return;
         }
     }
 
     // If only one value was specified, value2 is the same as value1.
     m_implicitShorthand = true;
-    value2 = cssValuePool().createIdentifierValue(toCSSPrimitiveValue(value1.get())->getValueID());
+    value2 = cssValuePool().createIdentifierValue(toCSSPrimitiveValue(value1)->getValueID());
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillSize(CSSPropertyID unresolvedProperty)
+NullableCSSValue CSSPropertyParser::parseFillSize(CSSPropertyID unresolvedProperty)
 {
     CSSParserValue* value = m_valueList->current();
     m_valueList->next();
 
     if (value->id == CSSValueContain || value->id == CSSValueCover)
         return cssValuePool().createIdentifierValue(value->id);
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = nullptr;
 
     if (value->id == CSSValueAuto)
@@ skipping 21 matching lines @@
         parsedValue2 = parsedValue1;
     }
 
     if (!parsedValue2)
         return parsedValue1;
 
     return createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release(), Pair::KeepIdenticalValues);
 }
 
 bool CSSPropertyParser::parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,
-    RefPtrWillBeRawPtr<CSSValue>& retValue1, RefPtrWillBeRawPtr<CSSValue>& retValue2)
+    NullableCSSValue& retValue1, NullableCSSValue& retValue2)
 {
     // We initially store the first value in value/value2, and only create
     // CSSValueLists if we have more values.
     RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
     RefPtrWillBeRawPtr<CSSValueList> values2 = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> value2 = nullptr;
+    NullableCSSValue value;
+    NullableCSSValue value2;
 
-    retValue1 = retValue2 = nullptr;
+    retValue1 = nullptr;
+    retValue2 = nullptr;
     propId1 = resolveCSSPropertyID(propId);
     propId2 = propId1;
     if (propId == CSSPropertyBackgroundPosition) {
         propId1 = CSSPropertyBackgroundPositionX;
         propId2 = CSSPropertyBackgroundPositionY;
     } else if (propId == CSSPropertyWebkitMaskPosition) {
         propId1 = CSSPropertyWebkitMaskPositionX;
         propId2 = CSSPropertyWebkitMaskPositionY;
     } else if (propId == CSSPropertyBackgroundRepeat) {
         propId1 = CSSPropertyBackgroundRepeatX;
         propId2 = CSSPropertyBackgroundRepeatY;
     } else if (propId == CSSPropertyWebkitMaskRepeat) {
         propId1 = CSSPropertyWebkitMaskRepeatX;
         propId2 = CSSPropertyWebkitMaskRepeatY;
     }
 
     while (true) {
-        RefPtrWillBeRawPtr<CSSValue> currValue = nullptr;
-        RefPtrWillBeRawPtr<CSSValue> currValue2 = nullptr;
+        NullableCSSValue currValue;
+        NullableCSSValue currValue2;
 
         Units unitless = FUnknown;
         CSSParserValue* val = m_valueList->current();
         ASSERT(val);
 
         switch (propId) {
         case CSSPropertyBackgroundColor:
             currValue = parseBackgroundColor();
             if (currValue)
                 m_valueList->next();
@@ skipping 95 matching lines @@
             break;
         }
         default:
             break;
         }
         if (!currValue)
             return false;
 
         if (value && !values) {
             values = CSSValueList::createCommaSeparated();
-            values->append(value.release());
+            values->append(*value);
         }
 
         if (value2 && !values2) {
             values2 = CSSValueList::createCommaSeparated();
-            values2->append(value2.release());
+            values2->append(*value2);
         }
 
         if (values)
-            values->append(currValue.release());
+            values->append(*currValue);
         else
-            value = currValue.release();
+            value = currValue;
         if (currValue2) {
             if (values2)
-                values2->append(currValue2.release());
+                values2->append(*currValue2);
             else
-                value2 = currValue2.release();
+                value2 = currValue2;
         }
 
         // When parsing any fill shorthand property, we let it handle building up the lists for all
         // properties.
         if (inShorthand())
             break;
 
         if (!m_valueList->current())
             break;
         if (!consumeComma(m_valueList) || !m_valueList->current())
             return false;
     }
 
     if (values) {
         ASSERT(values->length());
         retValue1 = values.release();
         if (values2) {
             ASSERT(values2->length());
             retValue2 = values2.release();
         }
     } else {
         ASSERT(value);
-        retValue1 = value.release();
-        retValue2 = value2.release();
+        retValue1 = value;
+        retValue2 = value2;
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDelay()
+NullableCSSValue CSSPropertyParser::parseAnimationDelay()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime))
         return createPrimitiveNumericValue(value);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDirection()
+NullableCSSValue CSSPropertyParser::parseAnimationDirection()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNormal || value->id == CSSValueAlternate || value->id == CSSValueReverse || value->id == CSSValueAlternateReverse)
         return cssValuePool().createIdentifierValue(value->id);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDuration()
+NullableCSSValue CSSPropertyParser::parseAnimationDuration()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime | FNonNeg))
         return createPrimitiveNumericValue(value);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationFillMode()
+NullableCSSValue CSSPropertyParser::parseAnimationFillMode()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth)
         return cssValuePool().createIdentifierValue(value->id);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationIterationCount()
+NullableCSSValue CSSPropertyParser::parseAnimationIterationCount()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueInfinite)
         return cssValuePool().createIdentifierValue(value->id);
     if (validUnit(value, FNumber | FNonNeg))
         return createPrimitiveNumericValue(value);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationName(bool allowQuotedName)
+NullableCSSValue CSSPropertyParser::parseAnimationName(bool allowQuotedName)
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     if (value->unit == CSSPrimitiveValue::CSS_IDENT)
         return createPrimitiveCustomIdentValue(value);
 
     if (allowQuotedName && value->unit == CSSPrimitiveValue::CSS_STRING) {
         // Legacy support for strings in prefixed animations
         if (m_context.useCounter())
             m_context.useCounter()->count(UseCounter::QuotedAnimationName);
         if (equalIgnoringCase(value->string, "none"))
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return createPrimitiveCustomIdentValue(value);
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationPlayState()
+NullableCSSValue CSSPropertyParser::parseAnimationPlayState()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueRunning || value->id == CSSValuePaused)
         return cssValuePool().createIdentifierValue(value->id);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty()
+NullableCSSValue CSSPropertyParser::parseAnimationProperty()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
     // Since all is valid css property keyword, cssPropertyID for all
     // returns non-null value. We need to check "all" before
     // cssPropertyID check.
     if (value->id == CSSValueAll)
         return cssValuePool().createIdentifierValue(CSSValueAll);
     CSSPropertyID property = unresolvedCSSPropertyID(value->string);
@@ skipping 14 matching lines @@
     if (!validUnit(v, FNumber))
         return false;
     result = v->fValue;
     v = args->next();
     if (!v)
         // The last number in the function has no comma after it, so we're done.
         return true;
     return consumeComma(args);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationTimingFunction()
+NullableCSSValue CSSPropertyParser::parseAnimationTimingFunction()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut
         || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd
         || value->id == CSSValueStepMiddle)
         return cssValuePool().createIdentifierValue(value->id);
 
     // We must be a function.
     if (value->unit != CSSParserValue::Function)
         return nullptr;
@@ skipping 60 matching lines @@
             return nullptr;
         if (!parseCubicBezierTimingFunctionValue(args, y2))
             return nullptr;
 
         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, bool useLegacyParsing)
+NullableCSSValue CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, bool useLegacyParsing)
 {
-    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+    NullableCSSValue value;
     switch (propId) {
     case CSSPropertyAnimationDelay:
     case CSSPropertyTransitionDelay:
         value = parseAnimationDelay();
         break;
     case CSSPropertyAnimationDirection:
         value = parseAnimationDirection();
         break;
     case CSSPropertyAnimationDuration:
     case CSSPropertyTransitionDuration:
@@ skipping 18 matching lines @@
     case CSSPropertyTransitionTimingFunction:
         value = parseAnimationTimingFunction();
         break;
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 
     if (value)
         m_valueList->next();
-    return value.release();
+    return value;
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseAnimationPropertyList(CSSPropertyID propId, bool useLegacyParsing)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     while (true) {
-        RefPtrWillBeRawPtr<CSSValue> value = parseAnimationProperty(propId, useLegacyParsing);
+        NullableCSSValue value = parseAnimationProperty(propId, useLegacyParsing);
         if (!value)
             return nullptr;
-        list->append(value.release());
+        list->append(*value);
         if (!m_valueList->current())
             break;
         if (!consumeComma(m_valueList) || !m_valueList->current())
             return nullptr;
     }
     if (propId == CSSPropertyTransitionProperty && !isValidTransitionPropertyList(list.get()))
         return nullptr;
     ASSERT(list->length());
     return list.release();
 }
@@ skipping 29 matching lines @@
         if (value && validUnit(value, FInteger) && value->fValue) {
             numericValue = createPrimitiveNumericValue(value);
             m_valueList->next();
         }
         return true;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridPosition()
+NullableCSSValue CSSPropertyParser::parseGridPosition()
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> numericValue = nullptr;
@@ skipping 35 matching lines @@
     if (hasSeenSpanKeyword)
         values->append(cssValuePool().createIdentifierValue(CSSValueSpan));
     if (numericValue)
         values->append(numericValue.release());
     if (gridLineName)
         values->append(gridLineName.release());
     ASSERT(values->length());
     return values.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> gridMissingGridPositionValue(CSSValue* value)
+static CSSValue gridMissingGridPositionValue(CSSValue value)
 {
-    if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->isString())
+    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).isString())
         return value;
 
     return cssValuePool().createIdentifierValue(CSSValueAuto);
 }
 
 bool CSSPropertyParser::parseGridItemPositionShorthand(CSSPropertyID shorthandId, bool important)
 {
     ShorthandScope scope(this, shorthandId);
     const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
     ASSERT(shorthand.length() == 2);
 
-    RefPtrWillBeRawPtr<CSSValue> startValue = parseGridPosition();
+    NullableCSSValue startValue = parseGridPosition();
     if (!startValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> endValue = nullptr;
+    NullableCSSValue endValue;
     if (m_valueList->current()) {
         if (!isForwardSlashOperator(m_valueList->current()))
             return false;
 
         if (!m_valueList->next())
             return false;
 
         endValue = parseGridPosition();
         if (!endValue || m_valueList->current())
             return false;
     } else {
-        endValue = gridMissingGridPositionValue(startValue.get());
+        endValue = gridMissingGridPositionValue(*startValue);
     }
 
-    addProperty(shorthand.properties()[0], startValue, important);
-    addProperty(shorthand.properties()[1], endValue, important);
+    addProperty(shorthand.properties()[0], *startValue, important);
+    addProperty(shorthand.properties()[1], *endValue, important);
     return true;
 }
 
-bool CSSPropertyParser::parseGridTemplateRowsAndAreas(PassRefPtrWillBeRawPtr<CSSValue> templateColumns, bool important)
+bool CSSPropertyParser::parseGridTemplateRowsAndAreas(NullableCSSValue templateColumns, bool important)
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
     bool trailingIdentWasAdded = false;
     RefPtrWillBeRawPtr<CSSValueList> templateRows = CSSValueList::createSpaceSeparated();
 
     // At least template-areas strings must be defined.
     if (!m_valueList->current())
         return false;
 
     while (m_valueList->current()) {
         // Handle leading <custom-ident>*.
-        if (!parseGridLineNames(*m_valueList, *templateRows, trailingIdentWasAdded ? toCSSGridLineNamesValue(templateRows->item(templateRows->length() - 1)) : nullptr))
+        if (!parseGridLineNames(*m_valueList, *templateRows, trailingIdentWasAdded ? toCSSGridLineNamesValue(NullableCSSValue(templateRows->item(templateRows->length() - 1))) : nullptr))
             return false;
 
         // Handle a template-area's row.
         if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
             return false;
         ++rowCount;
 
         // Handle template-rows's track-size.
         if (m_valueList->current() && m_valueList->current()->unit != CSSPrimitiveValue::CSS_STRING) {
-            RefPtrWillBeRawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            NullableCSSValue value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return false;
-            templateRows->append(value);
+            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();
+        trailingIdentWasAdded = templateRows->item(templateRows->length() - 1).isGridLineNamesValue();
     }
 
     // [<track-list> /]?
     if (templateColumns)
-        addProperty(CSSPropertyGridTemplateColumns, templateColumns, important);
+        addProperty(CSSPropertyGridTemplateColumns, *templateColumns, important);
     else
         addProperty(CSSPropertyGridTemplateColumns,  cssValuePool().createIdentifierValue(CSSValueNone), important);
 
     // [<line-names>? <string> [<track-size> <line-names>]? ]+
-    RefPtrWillBeRawPtr<CSSValue> templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
-    addProperty(CSSPropertyGridTemplateAreas, templateAreas.release(), important);
+    CSSValue templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
+    addProperty(CSSPropertyGridTemplateAreas, templateAreas, important);
     addProperty(CSSPropertyGridTemplateRows, templateRows.release(), 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;
     }
 
     unsigned index = 0;
-    RefPtrWillBeRawPtr<CSSValue> columnsValue = nullptr;
+    NullableCSSValue columnsValue;
     if (firstValueIsNone) {
         columnsValue = cssValuePool().createIdentifierValue(CSSValueNone);
     } else {
         columnsValue = parseGridTrackList();
     }
 
     // 2- <grid-template-columns> / <grid-template-columns> syntax.
     if (columnsValue) {
         if (!(m_valueList->current() && isForwardSlashOperator(m_valueList->current()) && m_valueList->next()))
             return false;
         index = m_valueList->currentIndex();
-        if (RefPtrWillBeRawPtr<CSSValue> rowsValue = parseGridTrackList()) {
+        if (NullableCSSValue rowsValue = parseGridTrackList()) {
             if (m_valueList->current())
                 return false;
-            addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
-            addProperty(CSSPropertyGridTemplateRows, rowsValue, important);
+            addProperty(CSSPropertyGridTemplateColumns, *columnsValue, important);
+            addProperty(CSSPropertyGridTemplateRows, *rowsValue, important);
             addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
             return true;
         }
     }
 
 
     // 3- [<track-list> /]? [<line-names>? <string> [<track-size> <line-names>]? ]+ syntax.
     // The template-columns <track-list> can't be 'none'.
     if (firstValueIsNone)
         return false;
@@ skipping 17 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-columns> [ / <grid-auto-rows> ]? ]
     if (!parseValue(CSSPropertyGridAutoFlow, important))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> autoColumnsValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> autoRowsValue = nullptr;
+    NullableCSSValue autoColumnsValue;
+    NullableCSSValue autoRowsValue;
 
     if (m_valueList->current()) {
         autoColumnsValue = parseGridTrackSize(*m_valueList);
         if (!autoColumnsValue)
             return false;
         if (m_valueList->current()) {
             if (!isForwardSlashOperator(m_valueList->current()) || !m_valueList->next())
                 return false;
             autoRowsValue = parseGridTrackSize(*m_valueList);
             if (!autoRowsValue)
                 return false;
         }
         if (m_valueList->current())
             return false;
     } else {
         // Other omitted values are set to their initial values.
         autoColumnsValue = cssValuePool().createImplicitInitialValue();
         autoRowsValue = cssValuePool().createImplicitInitialValue();
     }
 
     // if <grid-auto-rows> value is omitted, it is set to the value specified for grid-auto-columns.
     if (!autoRowsValue)
         autoRowsValue = autoColumnsValue;
 
-    addProperty(CSSPropertyGridAutoColumns, autoColumnsValue, important);
-    addProperty(CSSPropertyGridAutoRows, autoRowsValue, important);
+    addProperty(CSSPropertyGridAutoColumns, *autoColumnsValue, important);
+    addProperty(CSSPropertyGridAutoRows, *autoRowsValue, important);
 
     // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
     // The sub-properties not specified are set to their initial value, as normal for shorthands.
     addProperty(CSSPropertyGridTemplateColumns, cssValuePool().createImplicitInitialValue(), important);
     addProperty(CSSPropertyGridTemplateRows, cssValuePool().createImplicitInitialValue(), important);
     addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createImplicitInitialValue(), important);
 
     return true;
 }
 
 bool CSSPropertyParser::parseGridAreaShorthand(bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     ShorthandScope scope(this, CSSPropertyGridArea);
     const StylePropertyShorthand& shorthand = gridAreaShorthand();
     ASSERT_UNUSED(shorthand, shorthand.length() == 4);
 
-    RefPtrWillBeRawPtr<CSSValue> rowStartValue = parseGridPosition();
+    NullableCSSValue rowStartValue = parseGridPosition();
     if (!rowStartValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnStartValue = nullptr;
+    NullableCSSValue columnStartValue;
     if (!parseSingleGridAreaLonghand(columnStartValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> rowEndValue = nullptr;
+    NullableCSSValue rowEndValue;
     if (!parseSingleGridAreaLonghand(rowEndValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnEndValue = nullptr;
+    NullableCSSValue columnEndValue;
     if (!parseSingleGridAreaLonghand(columnEndValue))
         return false;
 
     if (!columnStartValue)
-        columnStartValue = gridMissingGridPositionValue(rowStartValue.get());
+        columnStartValue = gridMissingGridPositionValue(*rowStartValue);
 
     if (!rowEndValue)
-        rowEndValue = gridMissingGridPositionValue(rowStartValue.get());
+        rowEndValue = gridMissingGridPositionValue(*rowStartValue);
 
     if (!columnEndValue)
-        columnEndValue = gridMissingGridPositionValue(columnStartValue.get());
+        columnEndValue = gridMissingGridPositionValue(*columnStartValue);
 
-    addProperty(CSSPropertyGridRowStart, rowStartValue, important);
-    addProperty(CSSPropertyGridColumnStart, columnStartValue, important);
-    addProperty(CSSPropertyGridRowEnd, rowEndValue, important);
-    addProperty(CSSPropertyGridColumnEnd, columnEndValue, important);
+    addProperty(CSSPropertyGridRowStart, *rowStartValue, important);
+    addProperty(CSSPropertyGridColumnStart, *columnStartValue, important);
+    addProperty(CSSPropertyGridRowEnd, *rowEndValue, important);
+    addProperty(CSSPropertyGridColumnEnd, *columnEndValue, important);
     return true;
 }
 
-bool CSSPropertyParser::parseSingleGridAreaLonghand(RefPtrWillBeRawPtr<CSSValue>& property)
+bool CSSPropertyParser::parseSingleGridAreaLonghand(NullableCSSValue& property)
 {
     if (!m_valueList->current())
         return true;
 
     if (!isForwardSlashOperator(m_valueList->current()))
         return false;
 
     if (!m_valueList->next())
         return false;
 
     property = parseGridPosition();
     return true;
 }
 
 static inline bool isClosingBracket(const CSSParserValue& value)
 {
     return value.unit == CSSParserValue::Operator && value.iValue == ']';
 }
 
-bool CSSPropertyParser::parseGridLineNames(CSSParserValueList& inputList, CSSValueList& valueList, CSSGridLineNamesValue* previousNamedAreaTrailingLineNames)
+bool CSSPropertyParser::parseGridLineNames(CSSParserValueList& inputList, CSSValueList& valueList, NullableCSSValue previousNamedAreaTrailingLineNames)
 {
     if (!inputList.current() || inputList.current()->unit != CSSParserValue::Operator || inputList.current()->iValue != '[')
         return true;
 
     // Skip '['
     inputList.next();
 
-    RefPtrWillBeRawPtr<CSSGridLineNamesValue> lineNames = previousNamedAreaTrailingLineNames;
+    RefPtrWillBeRawPtr<CSSGridLineNamesValue> lineNames = toCSSGridLineNamesValue(previousNamedAreaTrailingLineNames);
     if (!lineNames)
         lineNames = CSSGridLineNamesValue::create();
 
     while (CSSParserValue* identValue = inputList.current()) {
         if (isClosingBracket(*identValue))
             break;
 
         if (!isValidCustomIdentForGridPositions(*identValue))
             return false;
 
         RefPtrWillBeRawPtr<CSSPrimitiveValue> lineName = createPrimitiveCustomIdentValue(identValue);
         lineNames->append(lineName.release());
         inputList.next();
     }
 
     if (!inputList.current() || !isClosingBracket(*inputList.current()))
         return false;
 
     if (!previousNamedAreaTrailingLineNames)
         valueList.append(lineNames.release());
 
     // Consume ']'
     inputList.next();
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridTrackList()
+NullableCSSValue CSSPropertyParser::parseGridTrackList()
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     // Handle leading  <custom-ident>*.
     if (!parseGridLineNames(*m_valueList, *values))
         return nullptr;
 
     bool seenTrackSizeOrRepeatFunction = false;
     while (CSSParserValue* currentValue = m_valueList->current()) {
         if (isForwardSlashOperator(currentValue))
             break;
         if (currentValue->unit == CSSParserValue::Function && currentValue->function->id == CSSValueRepeat) {
             if (!parseGridTrackRepeatFunction(*values))
                 return nullptr;
             seenTrackSizeOrRepeatFunction = true;
         } else {
-            RefPtrWillBeRawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            NullableCSSValue value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return nullptr;
-            values->append(value);
+            values->append(*value);
             seenTrackSizeOrRepeatFunction = true;
         }
         // This will handle the trailing <custom-ident>* in the grammar.
         if (!parseGridLineNames(*m_valueList, *values))
             return nullptr;
     }
 
     // We should have found a <track-size> or else it is not a valid <track-list>
     if (!seenTrackSizeOrRepeatFunction)
         return nullptr;
@@ skipping 13 matching lines @@
     RefPtrWillBeRawPtr<CSSValueList> repeatedValues = 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;
     while (arguments->current()) {
-        RefPtrWillBeRawPtr<CSSValue> trackSize = parseGridTrackSize(*arguments);
+        NullableCSSValue trackSize = parseGridTrackSize(*arguments);
         if (!trackSize)
             return false;
 
-        repeatedValues->append(trackSize);
+        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;
 
     // 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;
 }
 
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridTrackSize(CSSParserValueList& inputList)
+NullableCSSValue CSSPropertyParser::parseGridTrackSize(CSSParserValueList& inputList)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* currentValue = inputList.current();
     inputList.next();
 
     if (currentValue->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (currentValue->unit == CSSParserValue::Function && currentValue->function->id == CSSValueMinmax) {
@@ skipping 107 matching lines @@
 
             ++gridCoordinate.rows.resolvedFinalPosition;
         }
         currentCol = lookAheadCol;
     }
 
     m_valueList->next();
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridTemplateAreas()
+NullableCSSValue CSSPropertyParser::parseGridTemplateAreas()
 {
     if (m_valueList->current() && m_valueList->current()->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
 
     while (m_valueList->current()) {
         if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
             return nullptr;
         ++rowCount;
     }
 
     if (!rowCount || !columnCount)
         return nullptr;
 
     return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
+NullableCSSValue CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
 {
     // [ row | column ] || dense
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = list.current();
     if (!value)
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
 
@@ skipping 19 matching lines @@
         default:
             return parsedValues;
         }
         parsedValues->append(cssValuePool().createIdentifierValue(value->id));
         list.next();
     }
 
     return parsedValues;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
+NullableCSSValue CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
 {
     unsigned numArgs = args->size();
     if (counters && numArgs != 3 && numArgs != 5)
         return nullptr;
     if (!counters && numArgs != 1 && numArgs != 3)
         return nullptr;
 
     CSSParserValue* i = args->current();
     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
@@ skipping 257 matching lines @@
         if (!m_valueList->next() || m_valueList->current()->id != CSSValueLegacy)
             return false;
     } else {
         return false;
     }
 
     addProperty(propId, createPrimitiveValuePair(cssValuePool().createIdentifierValue(CSSValueLegacy), cssValuePool().createIdentifierValue(value->id)), important);
     return !m_valueList->next();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseContentDistributionOverflowPosition()
+NullableCSSValue CSSPropertyParser::parseContentDistributionOverflowPosition()
 {
     // auto | <baseline-position> | <content-distribution> || [ <overflow-position>? && <content-position> ]
     // <baseline-position> = baseline | last-baseline;
     // <content-distribution> = space-between | space-around | space-evenly | stretch;
     // <content-position> = center | start | end | flex-start | flex-end | left | right;
     // <overflow-position> = true | safe
 
     // auto | <baseline-position>
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto || isBaselinePositionKeyword(value->id)) {
@@ skipping 118 matching lines @@
         if (!args->currentIndex() && argument->id != CSSValueAt) {
             if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 shape->setRadius(radius);
                 continue;
             }
 
             return nullptr;
         }
 
         if (argument->id == CSSValueAt && args->next()) {
-            RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
-            RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
+            NullableCSSValue centerX;
+            NullableCSSValue centerY;
             parseFillPosition(args, centerX, centerY);
             if (centerX && centerY && !args->current()) {
                 ASSERT(centerX->isPrimitiveValue());
                 ASSERT(centerY->isPrimitiveValue());
-                shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
-                shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
+                shape->setCenterX(toCSSPrimitiveValue(centerX));
+                shape->setCenterY(toCSSPrimitiveValue(centerY));
             } else {
                 return nullptr;
             }
         } else {
             return nullptr;
         }
     }
 
     return shape;
 }
@@ skipping 24 matching lines @@
                 else
                     shape->setRadiusY(radius);
                 continue;
             }
 
             return nullptr;
         }
 
         if (argument->id != CSSValueAt || !args->next()) // expecting ellipse(.. at <position>)
             return nullptr;
-        RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
-        RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
+        NullableCSSValue centerX;
+        NullableCSSValue centerY;
         parseFillPosition(args, centerX, centerY);
         if (!centerX || !centerY || args->current())
             return nullptr;
 
         ASSERT(centerX->isPrimitiveValue());
         ASSERT(centerY->isPrimitiveValue());
-        shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
-        shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
+        shape->setCenterX(toCSSPrimitiveValue(centerX));
+        shape->setCenterY(toCSSPrimitiveValue(centerY));
     }
 
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(CSSParserValueList* args)
 {
     ASSERT(args);
 
     unsigned size = args->size();
@@ skipping 47 matching lines @@
     case CSSValueBorderBox:
     case CSSValueMarginBox:
         return true;
     default:
         break;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
+NullableCSSValue CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
 {
-    RefPtrWillBeRawPtr<CSSValue> imageValue = nullptr;
+    NullableCSSValue imageValue;
     if (parseFillImage(m_valueList, imageValue)) {
         m_valueList->next();
-        return imageValue.release();
+        return imageValue;
     }
 
     return parseBasicShapeAndOrBox();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBasicShapeAndOrBox()
+NullableCSSValue CSSPropertyParser::parseBasicShapeAndOrBox()
 {
     CSSParserValue* value = m_valueList->current();
 
     bool shapeFound = false;
     bool boxFound = false;
     CSSValueID valueId;
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (unsigned i = 0; i < 2; ++i) {
         if (!value)
@@ skipping 111 matching lines @@
             return false;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = parseLineHeight();
         if (!lineHeight)
             return false;
         addProperty(CSSPropertyLineHeight, lineHeight.release(), important);
     } else {
         addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
     }
 
     // Font family must come now.
-    RefPtrWillBeRawPtr<CSSValue> parsedFamilyValue = parseFontFamily();
+    NullableCSSValue parsedFamilyValue = parseFontFamily();
     if (!parsedFamilyValue)
         return false;
 
-    addProperty(CSSPropertyFontFamily, parsedFamilyValue.release(), important);
+    addProperty(CSSPropertyFontFamily, *parsedFamilyValue, important);
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that
     // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values
     // but we don't seem to support them at the moment. They should also be added here once implemented.
     if (m_valueList->current())
         return false;
 
     return true;
 }
 
@@ skipping 996 matching lines @@
 
     if (context.allowBreak) {
         context.commitValue();
         if (context.values && context.values->length())
             return context.values.release();
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseReflect()
+NullableCSSValue CSSPropertyParser::parseReflect()
 {
     // box-reflect: <direction> <offset> <mask>
 
     // Direction comes first.
     CSSParserValue* val = m_valueList->current();
     RefPtrWillBeRawPtr<CSSPrimitiveValue> direction = nullptr;
     switch (val->id) {
     case CSSValueAbove:
     case CSSValueBelow:
     case CSSValueLeft:
     case CSSValueRight:
         direction = cssValuePool().createIdentifierValue(val->id);
         break;
     default:
         return nullptr;
     }
 
     // The offset comes next.
     val = m_valueList->next();
     RefPtrWillBeRawPtr<CSSPrimitiveValue> offset = nullptr;
     if (!val)
         offset = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX);
     else {
         if (!validUnit(val, FLength | FPercent))
             return nullptr;
         offset = createPrimitiveNumericValue(val);
     }
 
     // Now for the mask.
-    RefPtrWillBeRawPtr<CSSValue> mask = nullptr;
+    NullableCSSValue mask;
     val = m_valueList->next();
     if (val) {
         mask = parseBorderImage(CSSPropertyWebkitBoxReflect);
         if (!mask)
             return nullptr;
     }
 
-    return CSSReflectValue::create(direction.release(), offset.release(), mask.release());
+    return CSSReflectValue::create(direction.get(), offset.get(), mask);
 }
 
 static bool isFlexBasisMiddleArg(double flexGrow, double flexShrink, double unsetValue, int argSize)
 {
     return flexGrow != unsetValue && flexShrink == unsetValue &&  argSize == 3;
 }
 
 bool CSSPropertyParser::parseFlex(CSSParserValueList* args, bool important)
 {
     if (!args || !args->size() || args->size() > 3)
@@ skipping 31 matching lines @@
         flexShrink = 1;
     if (!flexBasis)
         flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PERCENTAGE);
 
     addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::CSS_NUMBER), important);
     addProperty(CSSPropertyFlexBasis, flexBasis, important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parsePosition(CSSParserValueList* valueList)
+NullableCSSValue CSSPropertyParser::parsePosition(CSSParserValueList* valueList)
 {
-    RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
+    NullableCSSValue xValue;
+    NullableCSSValue yValue;
     parseFillPosition(valueList, xValue, yValue);
+
     if (!xValue || !yValue)
         return nullptr;
-    return createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues);
+    return createPrimitiveValuePair(toCSSPrimitiveValue(xValue), toCSSPrimitiveValue(yValue), Pair::KeepIdenticalValues);
 }
 
 // Parses a list of comma separated positions. i.e., <position>#
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parsePositionList(CSSParserValueList* valueList)
+NullableCSSValue CSSPropertyParser::parsePositionList(CSSParserValueList* valueList)
 {
     RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
     while (true) {
         // parsePosition consumes values until it reaches a separator [,/],
         // an invalid token, or end of the list
-        RefPtrWillBeRawPtr<CSSValue> position = parsePosition(valueList);
+        NullableCSSValue position = parsePosition(valueList);
         if (!position)
             return nullptr;
-        positions->append(position);
+        positions->append(*position);
 
         if (!valueList->current())
             break;
         if (!consumeComma(valueList) || !valueList->current())
             return nullptr;
     }
 
     return positions.release();
 }
 
@@ skipping 16 matching lines @@
 
     bool allowCommit() const { return m_allowCommit; }
     bool allowImage() const { return m_allowImage; }
     bool allowImageSlice() const { return m_allowImageSlice; }
     bool allowRepeat() const { return m_allowRepeat; }
     bool allowForwardSlashOperator() const { return m_allowForwardSlashOperator; }
 
     bool allowWidth() const { return m_allowWidth; }
     bool requireOutset() const { return m_requireOutset; }
 
-    void commitImage(PassRefPtrWillBeRawPtr<CSSValue> image)
+    void commitImage(CSSValue image)
     {
         m_image = image;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowImage = false;
         m_allowForwardSlashOperator = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImageSlice = !m_imageSlice;
         m_allowRepeat = !m_repeat;
@@ skipping 44 matching lines @@
         m_outset = outset;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowImageSlice = false;
         m_allowForwardSlashOperator = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
     }
-    void commitRepeat(PassRefPtrWillBeRawPtr<CSSValue> repeat)
+    void commitRepeat(CSSValue repeat)
     {
         m_repeat = repeat;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowRepeat = false;
         m_allowForwardSlashOperator = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImageSlice = !m_imageSlice;
         m_allowImage = !m_image;
     }
 
-    PassRefPtrWillBeRawPtr<CSSValue> commitCSSValue()
+    CSSValue commitCSSValue()
     {
-        return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat.get());
+        return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat);
     }
 
     bool m_canAdvance;
 
     bool m_allowCommit;
     bool m_allowImage;
     bool m_allowImageSlice;
     bool m_allowRepeat;
     bool m_allowForwardSlashOperator;
 
     bool m_allowWidth;
     bool m_requireOutset;
 
-    RefPtrWillBeMember<CSSValue> m_image;
+    NullableCSSValue m_image;
     RefPtrWillBeMember<CSSBorderImageSliceValue> m_imageSlice;
     RefPtrWillBeMember<CSSPrimitiveValue> m_borderWidth;
     RefPtrWillBeMember<CSSPrimitiveValue> m_outset;
 
-    RefPtrWillBeMember<CSSValue> m_repeat;
+    NullableCSSValue m_repeat;
 };
 
 bool CSSPropertyParser::buildBorderImageParseContext(CSSPropertyID propId, BorderImageParseContext& context)
 {
     CSSPropertyParser::ShorthandScope scope(this, propId);
     while (CSSParserValue* val = m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
             if (val->unit == CSSPrimitiveValue::CSS_URI) {
                 context.commitImage(createCSSImageValueWithReferrer(val->string, m_context.completeURL(val->string)));
             } else if (isGeneratedImageValue(val)) {
-                RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+                NullableCSSValue value;
                 if (parseGeneratedImage(m_valueList, value))
-                    context.commitImage(value.release());
+                    context.commitImage(*value);
                 else
                     return false;
             } else if (val->unit == CSSParserValue::Function && val->function->id == CSSValueWebkitImageSet) {
-                RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
+                NullableCSSValue value = parseImageSet(m_valueList);
                 if (value)
-                    context.commitImage(value.release());
+                    context.commitImage(*value);
                 else
                     return false;
             } else if (val->id == CSSValueNone)
                 context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
         }
 
         if (!context.canAdvance() && context.allowImageSlice()) {
             RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
             if (parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
         if (!context.canAdvance() && context.allowRepeat()) {
-            RefPtrWillBeRawPtr<CSSValue> repeat = nullptr;
+            NullableCSSValue repeat;
             if (parseBorderImageRepeat(repeat))
-                context.commitRepeat(repeat.release());
+                context.commitRepeat(*repeat);
         }
 
         if (!context.canAdvance() && context.allowWidth()) {
             RefPtrWillBeRawPtr<CSSPrimitiveValue> borderWidth = nullptr;
             if (parseBorderImageWidth(borderWidth))
                 context.commitBorderWidth(borderWidth.release());
         }
 
         if (!context.canAdvance() && context.requireOutset()) {
             RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset = nullptr;
             if (parseBorderImageOutset(borderOutset))
                 context.commitBorderOutset(borderOutset.release());
         }
 
         if (!context.canAdvance())
             return false;
 
         m_valueList->next();
     }
 
     return context.allowCommit();
 }
 
-void CSSPropertyParser::commitBorderImageProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important)
+void CSSPropertyParser::commitBorderImageProperty(CSSPropertyID propId, NullableCSSValue value, bool important)
 {
     if (value)
-        addProperty(propId, value, important);
+        addProperty(propId, *value, important);
     else
         addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
 }
 
 bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId, bool important)
 {
     BorderImageParseContext context;
     if (buildBorderImageParseContext(propId, context)) {
         switch (propId) {
         case CSSPropertyWebkitMaskBoxImage:
             commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, context.m_image, important);
             commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, context.m_imageSlice.get(), important);
             commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, context.m_borderWidth.get(), important);
             commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, context.m_outset.get(), important);
-            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, context.m_repeat.get(), important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, context.m_repeat, important);
             return true;
         case CSSPropertyBorderImage:
             commitBorderImageProperty(CSSPropertyBorderImageSource, context.m_image, important);
             commitBorderImageProperty(CSSPropertyBorderImageSlice, context.m_imageSlice.get(), important);
             commitBorderImageProperty(CSSPropertyBorderImageWidth, context.m_borderWidth.get(), important);
             commitBorderImageProperty(CSSPropertyBorderImageOutset, context.m_outset.get(), important);
             commitBorderImageProperty(CSSPropertyBorderImageRepeat, context.m_repeat, important);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
+NullableCSSValue CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
 {
     BorderImageParseContext context;
     if (buildBorderImageParseContext(propId, context)) {
         return context.commitCSSValue();
     }
     return nullptr;
 }
 
 static bool isBorderImageRepeatKeyword(int id)
 {
     return id == CSSValueStretch || id == CSSValueRepeat || id == CSSValueSpace || id == CSSValueRound;
 }
 
-bool CSSPropertyParser::parseBorderImageRepeat(RefPtrWillBeRawPtr<CSSValue>& result)
+bool CSSPropertyParser::parseBorderImageRepeat(NullableCSSValue& result)
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> firstValue = nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> secondValue = nullptr;
     CSSParserValue* val = m_valueList->current();
     if (!val)
         return false;
     if (isBorderImageRepeatKeyword(val->id))
         firstValue = cssValuePool().createIdentifierValue(val->id);
     else
         return false;
@@ skipping 288 matching lines @@
         completeBorderRadii(radii[1]);
 
     ImplicitScope implicitScope(this);
     addProperty(CSSPropertyBorderTopLeftRadius, createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()), important);
     addProperty(CSSPropertyBorderTopRightRadius, createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()), important);
     addProperty(CSSPropertyBorderBottomRightRadius, createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()), important);
     addProperty(CSSPropertyBorderBottomLeftRadius, createPrimitiveValuePair(radii[0][3].release(), radii[1][3].release()), important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounter(int defaultValue)
+NullableCSSValue CSSPropertyParser::parseCounter(int defaultValue)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->unit != CSSPrimitiveValue::CSS_IDENT)
             return nullptr;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName = createPrimitiveCustomIdentValue(val);
         m_valueList->next();
 
@@ skipping 88 matching lines @@
             stop.m_color = cssValuePool().createIdentifierValue(id);
         else
             stop.m_color = parseColor(stopArg);
         if (!stop.m_color)
             return false;
     }
 
     return true;
 }
 
-bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient)
+bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, NullableCSSValue& gradient)
 {
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || args->size() == 0)
         return false;
 
     // The first argument is the gradient type.  It is an identifier.
     CSSGradientType gradientType;
     CSSParserValue* a = args->current();
     if (!a || a->unit != CSSPrimitiveValue::CSS_IDENT)
@@ skipping 132 matching lines @@
         case CSSValueTop:
         case CSSValueBottom:
             isHorizontal = false;
             break;
         default:
             return nullptr;
     }
     return cssValuePool().createIdentifierValue(a->id);
 }
 
-bool CSSPropertyParser::parseDeprecatedLinearGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
+bool CSSPropertyParser::parseDeprecatedLinearGradient(CSSParserValueList* valueList, NullableCSSValue& gradient, CSSGradientRepeat repeating)
 {
     RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSPrefixedLinearGradient);
 
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
@@ skipping 49 matching lines @@
     if (!parseGradientColorStops(args, result.get(), expectComma))
         return false;
 
     if (!result->stopCount())
         return false;
 
     gradient = result.release();
     return true;
 }
 
-bool CSSPropertyParser::parseDeprecatedRadialGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
+bool CSSPropertyParser::parseDeprecatedRadialGradient(CSSParserValueList* valueList, NullableCSSValue& gradient, CSSGradientRepeat repeating)
 {
     RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
 
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
         return false;
 
     bool expectComma = false;
 
     // Optional background-position
-    RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
+    NullableCSSValue centerX;
+    NullableCSSValue centerY;
     // parse2ValuesFillPosition advances the args next pointer.
     parse2ValuesFillPosition(args, centerX, centerY);
 
     if ((centerX || centerY) && !consumeComma(args))
         return false;
 
     a = args->current();
     if (!a)
         return false;
 
-    result->setFirstX(toCSSPrimitiveValue(centerX.get()));
-    result->setSecondX(toCSSPrimitiveValue(centerX.get()));
+    result->setFirstX(toCSSPrimitiveValue(centerX));
+    result->setSecondX(toCSSPrimitiveValue(centerX));
     // CSS3 radial gradients always share the same start and end point.
-    result->setFirstY(toCSSPrimitiveValue(centerY.get()));
-    result->setSecondY(toCSSPrimitiveValue(centerY.get()));
+    result->setFirstY(toCSSPrimitiveValue(centerY));
+    result->setSecondY(toCSSPrimitiveValue(centerY));
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue = nullptr;
 
     // Optional shape and/or size in any order.
     for (int i = 0; i < 2; ++i) {
         if (a->unit != CSSPrimitiveValue::CSS_IDENT)
             break;
 
         bool foundValue = false;
@@ skipping 59 matching lines @@
     result->setEndHorizontalSize(horizontalSize);
     result->setEndVerticalSize(verticalSize);
 
     if (!parseGradientColorStops(args, result.get(), expectComma))
         return false;
 
     gradient = result.release();
     return true;
 }
 
-bool CSSPropertyParser::parseLinearGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
+bool CSSPropertyParser::parseLinearGradient(CSSParserValueList* valueList, NullableCSSValue& gradient, CSSGradientRepeat repeating)
 {
     RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSLinearGradient);
 
     CSSParserFunction* function = valueList->current()->function;
     CSSParserValueList* args = function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
@@ skipping 53 matching lines @@
     if (!parseGradientColorStops(args, result.get(), expectComma))
         return false;
 
     if (!result->stopCount())
         return false;
 
     gradient = result.release();
     return true;
 }
 
-bool CSSPropertyParser::parseRadialGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
+bool CSSPropertyParser::parseRadialGradient(CSSParserValueList* valueList, NullableCSSValue& gradient, CSSGradientRepeat repeating)
 {
     RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
 
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
     if (!a)
         return false;
@@ skipping 71 matching lines @@
     if (!verticalSize && horizontalSize && horizontalSize->isPercentage())
         return false;
 
     result->setShape(shapeValue);
     result->setSizingBehavior(sizeValue);
     result->setEndHorizontalSize(horizontalSize);
     result->setEndVerticalSize(verticalSize);
 
     // Second part of grammar, the center-position clause:
     // at <position>
-    RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
+    NullableCSSValue centerX;
+    NullableCSSValue centerY;
     if (a->unit == CSSPrimitiveValue::CSS_IDENT && a->id == CSSValueAt) {
         a = args->next();
         if (!a)
             return false;
 
         parseFillPosition(args, centerX, centerY);
         if (!(centerX && centerY))
             return false;
 
         a = args->current();
         if (!a)
             return false;
-        result->setFirstX(toCSSPrimitiveValue(centerX.get()));
-        result->setFirstY(toCSSPrimitiveValue(centerY.get()));
+        result->setFirstX(toCSSPrimitiveValue(centerX));
+        result->setFirstY(toCSSPrimitiveValue(centerY));
         // Right now, CSS radial gradients have the same start and end centers.
-        result->setSecondX(toCSSPrimitiveValue(centerX.get()));
-        result->setSecondY(toCSSPrimitiveValue(centerY.get()));
+        result->setSecondX(toCSSPrimitiveValue(centerX));
+        result->setSecondY(toCSSPrimitiveValue(centerY));
     }
 
     if (shapeValue || sizeValue || horizontalSize || centerX || centerY)
         expectComma = true;
 
     if (!parseGradientColorStops(args, result.get(), expectComma))
         return false;
 
     gradient = result.release();
     return true;
@@ skipping 54 matching lines @@
     }
 
     // The last color stop cannot be a color hint.
     if (previousStopWasColorHint)
         return false;
 
     // Must have 2 or more stops to be valid.
     return gradient->stopCount() >= 2;
 }
 
-bool CSSPropertyParser::parseGeneratedImage(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value)
+bool CSSPropertyParser::parseGeneratedImage(CSSParserValueList* valueList, NullableCSSValue& value)
 {
     CSSParserValue* val = valueList->current();
 
     if (val->unit != CSSParserValue::Function)
         return false;
 
     if (val->function->id == CSSValueWebkitGradient) {
         // FIXME: This should send a deprecation message.
         if (m_context.useCounter())
             m_context.useCounter()->count(UseCounter::DeprecatedWebKitGradient);
@@ skipping 41 matching lines @@
 
     if (val->function->id == CSSValueWebkitCanvas)
         return parseCanvas(valueList, value);
 
     if (val->function->id == CSSValueWebkitCrossFade)
         return parseCrossfade(valueList, value);
 
     return false;
 }
 
-bool CSSPropertyParser::parseCrossfade(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& crossfade)
+bool CSSPropertyParser::parseCrossfade(CSSParserValueList* valueList, NullableCSSValue& crossfade)
 {
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || args->size() != 5)
         return false;
-    RefPtrWillBeRawPtr<CSSValue> fromImageValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> toImageValue = nullptr;
+    NullableCSSValue fromImageValue;
+    NullableCSSValue toImageValue;
 
     // The first argument is the "from" image. It is a fill image.
     if (!args->current() || !parseFillImage(args, fromImageValue))
         return false;
     args->next();
 
     if (!consumeComma(args))
         return false;
 
     // The second argument is the "to" image. It is a fill image.
@@ skipping 10 matching lines @@
     if (!value)
         return false;
 
     if (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
         percentage = cssValuePool().createValue(clampTo<double>(value->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
     else if (value->unit == CSSPrimitiveValue::CSS_NUMBER)
         percentage = cssValuePool().createValue(clampTo<double>(value->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER);
     else
         return false;
 
-    RefPtrWillBeRawPtr<CSSCrossfadeValue> result = CSSCrossfadeValue::create(fromImageValue, toImageValue);
+    RefPtrWillBeRawPtr<CSSCrossfadeValue> result = CSSCrossfadeValue::create(*fromImageValue, *toImageValue);
     result->setPercentage(percentage);
 
     crossfade = result;
 
     return true;
 }
 
-bool CSSPropertyParser::parseCanvas(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& canvas)
+bool CSSPropertyParser::parseCanvas(CSSParserValueList* valueList, NullableCSSValue& canvas)
 {
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || args->size() != 1)
         return false;
 
     // The first argument is the canvas name.  It is an identifier.
     CSSParserValue* value = args->current();
     if (!value || value->unit != CSSPrimitiveValue::CSS_IDENT)
         return false;
 
     canvas = CSSCanvasValue::create(value->string);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
+NullableCSSValue CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
 {
     CSSParserValue* function = valueList->current();
 
     if (function->unit != CSSParserValue::Function)
         return nullptr;
 
     CSSParserValueList* functionArgs = valueList->current()->function->args.get();
     if (!functionArgs || !functionArgs->size() || !functionArgs->current())
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
 
     while (functionArgs->current()) {
         CSSParserValue* arg = functionArgs->current();
         if (arg->unit != CSSPrimitiveValue::CSS_URI)
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSValue> image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
+        CSSValue image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
         imageSet->append(image);
 
         arg = functionArgs->next();
         if (!arg)
             return nullptr;
 
         if (arg->unit != CSSParserValue::DimensionList)
             return nullptr;
         ASSERT(arg->valueList->valueAt(0)->unit == CSSPrimitiveValue::CSS_NUMBER);
         ASSERT(arg->valueList->valueAt(1)->unit == CSSPrimitiveValue::CSS_IDENT);
@@ skipping 10 matching lines @@
             break;
 
         // If there are more arguments, they should be after a comma.
         if (!consumeComma(functionArgs))
             return nullptr;
     }
 
     return imageSet.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseWillChange()
+NullableCSSValue CSSPropertyParser::parseWillChange()
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     if (m_valueList->current()->id == CSSValueAuto) {
         // FIXME: This will be read back as an empty string instead of auto
         return values.release();
     }
 
     // Every comma-separated list of CSS_IDENTs is a valid will-change value,
     // unless the list includes an explicitly disallowed CSS_IDENT.
     while (true) {
@@ skipping 152 matching lines @@
         }
     }
 
     return list.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransformOrigin()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
-    RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> zValue = nullptr;
+    NullableCSSValue xValue;
+    NullableCSSValue yValue;
+    NullableCSSValue zValue;
     if (id == CSSValueLeft || id == CSSValueRight) {
         xValue = cssValuePool().createIdentifierValue(id);
     } else if (id == CSSValueTop || id == CSSValueBottom) {
         yValue = cssValuePool().createIdentifierValue(id);
     } else if (id == CSSValueCenter) {
         // Unresolved as to whether this is X or Y.
     } else if (validUnit(value, FPercent | FLength)) {
         xValue = createPrimitiveNumericValue(value);
     } else {
         return nullptr;
@@ skipping 32 matching lines @@
         }
     } else if (!xValue) {
         if (yValue) {
             xValue = cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
         } else {
             xValue = cssValuePool().createIdentifierValue(CSSValueCenter);
         }
     }
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-    list->append(xValue.release());
+    list->append(*xValue);
     if (yValue)
-        list->append(yValue.release());
+        list->append(*yValue);
     if (zValue)
-        list->append(zValue.release());
+        list->append(*zValue);
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTouchAction()
+NullableCSSValue CSSPropertyParser::parseTouchAction()
 {
     CSSParserValue* value = m_valueList->current();
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     if (m_valueList->size() == 1 && value && (value->id == CSSValueAuto || value->id == CSSValueNone || value->id == CSSValueManipulation)) {
         list->append(cssValuePool().createIdentifierValue(value->id));
         m_valueList->next();
         return list.release();
     }
 
     bool xSet = false;
     bool ySet = false;
     while (value) {
         switch (value->id) {
         case CSSValuePanX:
         case CSSValuePanRight:
         case CSSValuePanLeft: {
             if (xSet)
                 return nullptr;
             xSet = true;
             if (value->id != CSSValuePanX && !RuntimeEnabledFeatures::cssTouchActionPanDirectionsEnabled())
                 return nullptr;
 
-            RefPtrWillBeRawPtr<CSSValue> panValue = cssValuePool().createIdentifierValue(value->id);
-            list->append(panValue.release());
+            CSSValue panValue = cssValuePool().createIdentifierValue(value->id);
+            list->append(panValue);
             break;
         }
         case CSSValuePanY:
         case CSSValuePanDown:
         case CSSValuePanUp: {
             if (ySet)
                 return nullptr;
             ySet = true;
             if (value->id != CSSValuePanY && !RuntimeEnabledFeatures::cssTouchActionPanDirectionsEnabled())
                 return nullptr;
-            RefPtrWillBeRawPtr<CSSValue> panValue = cssValuePool().createIdentifierValue(value->id);
-            list->append(panValue.release());
+            CSSValue panValue = cssValuePool().createIdentifierValue(value->id);
+            list->append(panValue);
             break;
         }
         default:
             return nullptr;
         }
         value = m_valueList->next();
     }
 
     if (list->length())
         return list.release();
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollBlocksOn()
+NullableCSSValue CSSPropertyParser::parseScrollBlocksOn()
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     CSSParserValue* value = m_valueList->current();
     while (value) {
         switch (value->id) {
         case CSSValueStartTouch:
         case CSSValueWheelEvent:
         case CSSValueScrollEvent: {
-            RefPtrWillBeRawPtr<CSSValue> flagValue = cssValuePool().createIdentifierValue(value->id);
-            if (list->hasValue(flagValue.get()))
+            CSSValue flagValue = cssValuePool().createIdentifierValue(value->id);
+            if (list->hasValue(flagValue))
                 return nullptr;
-            list->append(flagValue.release());
+            list->append(flagValue);
             break;
         }
         default:
             return nullptr;
         }
         value = m_valueList->next();
     }
 
     ASSERT(list->length());
     return list.release();
 }
 
-void CSSPropertyParser::addTextDecorationProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important)
+void CSSPropertyParser::addTextDecorationProperty(CSSPropertyID propId, CSSValue value, bool important)
 {
     // The text-decoration-line property takes priority over text-decoration, unless the latter has important priority set.
     if (propId == CSSPropertyTextDecoration && !important && !inShorthand()) {
         for (unsigned i = 0; i < m_parsedProperties.size(); ++i) {
             if (m_parsedProperties[i].id() == CSSPropertyTextDecorationLine)
                 return;
         }
     }
     addProperty(propId, value, important);
 }
@@ skipping 29 matching lines @@
 
     // Values are either valid or in shorthand scope.
     if (list->length() && (isValid || inShorthand())) {
         addTextDecorationProperty(propId, list.release(), important);
         return true;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextEmphasisStyle()
+NullableCSSValue CSSPropertyParser::parseTextEmphasisStyle()
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = nullptr;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit == CSSPrimitiveValue::CSS_STRING) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
             return createPrimitiveStringValue(value);
@@ skipping 26 matching lines @@
         return parsedValues.release();
     }
     if (fill)
         return fill.release();
     if (shape)
         return shape.release();
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextIndent()
+NullableCSSValue CSSPropertyParser::parseTextIndent()
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
     bool hasLengthOrPercentage = false;
     bool hasEachLine = false;
     bool hasHanging = false;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         // <length> | <percentage> | inherit when RuntimeEnabledFeatures::css3TextEnabled() returns false
         if (!hasLengthOrPercentage && validUnit(value, FLength | FPercent | FUnitlessQuirk)) {
@@ skipping 85 matching lines @@
             m_valueList->next();
         } else if (value->id == CSSValueOn || value->id == CSSValueOff) {
             tagValue = value->id == CSSValueOn;
             m_valueList->next();
         }
     }
     settings->append(CSSFontFeatureValue::create(tag, tagValue));
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFontFeatureSettings()
+NullableCSSValue CSSPropertyParser::parseFontFeatureSettings()
 {
     RefPtrWillBeRawPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
     while (true) {
         if (!m_valueList->current() || !parseFontFeatureTag(settings.get()))
             return nullptr;
         if (!m_valueList->current())
             break;
         if (!consumeComma(m_valueList))
             return nullptr;
     }
@@ skipping 68 matching lines @@
         return false;
 
     return true;
 }
 
 bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
     CSSValueID id = value->id;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+    NullableCSSValue parsedValue;
 
     switch (propId) {
     case CSSPropertyFontFamily:
         // <family-name>
         // TODO(rwlbuis): check there is only one family-name
         parsedValue = parseFontFamily();
         break;
     case CSSPropertySrc: // This is a list of urls or local references.
         parsedValue = parseFontFaceSrc();
         break;
@@ skipping 20 matching lines @@
             parsedValue = parseFontFeatureSettings();
         }
         break;
     default:
         break;
     }
 
     if (!parsedValue || m_valueList->current())
         return false;
 
-    addProperty(propId, parsedValue.release(), false);
+    addProperty(propId, *parsedValue, false);
     return true;
 }
 
 bool CSSPropertyParser::parseViewportProperty(CSSPropertyID propId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
@@ skipping 27 matching lines @@
         if (id == CSSValueZoom || id == CSSValueFixed)
             validPrimitive = true;
         break;
     case CSSPropertyOrientation: // auto | portrait | landscape
         if (id == CSSValueAuto || id == CSSValuePortrait || id == CSSValueLandscape)
             validPrimitive = true;
     default:
         break;
     }
 
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+    NullableCSSValue parsedValue;
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
 
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, *parsedValue, important);
             return true;
         }
     }
 
     return false;
 }
 
 bool CSSPropertyParser::parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
@@ skipping 112 matching lines @@
 }
 
 bool CSSPropertyParser::parseSVGValue(CSSPropertyID propId, bool important)
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
 
     CSSValueID id = value->id;
 
     bool validPrimitive = false;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+    NullableCSSValue parsedValue;
 
     switch (propId) {
     /* The comment to the right defines all valid value of these
      * properties as defined in SVG 1.1, Appendix N. Property index */
     case CSSPropertyAlignmentBaseline:
     // auto | baseline | before-edge | text-before-edge | middle |
     // central | after-edge | text-after-edge | ideographic | alphabetic |
     // hanging | mathematical | inherit
         if (id == CSSValueAuto || id == CSSValueBaseline || id == CSSValueMiddle
             || (id >= CSSValueBeforeEdge && id <= CSSValueMathematical))
@@ skipping 124 matching lines @@
             } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
                 RGBA32 c = Color::transparent;
                 if (m_valueList->next()) {
                     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
                     values->append(CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI));
                     if (parseColorFromValue(m_valueList->current(), c))
                         parsedValue = cssValuePool().createColorValue(c);
                     else if (m_valueList->current()->id == CSSValueNone || m_valueList->current()->id == CSSValueCurrentcolor)
                         parsedValue = cssValuePool().createIdentifierValue(m_valueList->current()->id);
                     if (parsedValue) {
-                        values->append(parsedValue);
+                        values->append(*parsedValue);
                         parsedValue = values;
                     }
                 }
                 if (!parsedValue)
                     parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
             } else {
                 parsedValue = parseColor();
             }
 
             if (parsedValue)
@@ skipping 60 matching lines @@
     /* shorthand properties */
     case CSSPropertyMarker: {
         ShorthandScope scope(this, propId);
         CSSPropertyParser::ImplicitScope implicitScope(this);
         if (!parseValue(CSSPropertyMarkerStart, important))
             return false;
         if (m_valueList->current()) {
             rollbackLastProperties(1);
             return false;
         }
-        CSSValue* value = m_parsedProperties.last().value();
+        CSSValue value = m_parsedProperties.last().value();
         addProperty(CSSPropertyMarkerMid, value, important);
         addProperty(CSSPropertyMarkerEnd, value, important);
         return true;
     }
     default:
         // If you crash here, it's because you added a css property and are not handling it
         // in either this switch statement or the one in CSSPropertyParser::parseValue
         ASSERT_WITH_MESSAGE(0, "unimplemented propertyID: %d", propId);
         return false;
     }
@@ skipping 13 matching lines @@
             // FIXME calc() http://webkit.org/b/16662 : actually create a CSSPrimitiveValue here, ie
             // parsedValue = CSSPrimitiveValue::create(m_parsedCalculation.release());
             m_parsedCalculation.release();
             parsedValue = nullptr;
         }
         m_valueList->next();
     }
     if (!parsedValue || (m_valueList->current() && !inShorthand()))
         return false;
 
-    addProperty(propId, parsedValue.release(), important);
+    addProperty(propId, *parsedValue, important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSVGStrokeDasharray()
+NullableCSSValue CSSPropertyParser::parseSVGStrokeDasharray()
 {
     RefPtrWillBeRawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
     CSSParserValue* value = m_valueList->current();
     bool validPrimitive = true;
     while (value) {
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg, SVGAttributeMode);
         if (!validPrimitive)
             break;
         if (value->id)
             ret->append(CSSPrimitiveValue::createIdentifier(value->id));
         else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
             ret->append(CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitType) value->unit));
         else if (value->unit == CSSPrimitiveValue::CSS_REMS || value->unit == CSSPrimitiveValue::CSS_CHS)
             ret->append(CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitType)value->unit));
         value = m_valueList->next();
         bool commaConsumed = consumeComma(m_valueList);
         value = m_valueList->current();
         if (commaConsumed && !value)
             return nullptr;
     }
     if (!validPrimitive)
         return nullptr;
     return ret.release();
 }
 
 // normal | [ fill || stroke || markers ]
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parsePaintOrder() const
+NullableCSSValue CSSPropertyParser::parsePaintOrder() const
 {
     if (m_valueList->size() > 3)
         return nullptr;
 
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
 
     RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
 
     // The default paint-order is: Fill, Stroke, Markers.
@@ skipping 142 matching lines @@
     CSSPropertyParser::Units m_unit;
 };
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransform(bool useLegacyParsing)
 {
     if (!m_valueList)
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = parseTransformValue(useLegacyParsing, value);
+        NullableCSSValue parsedTransformValue = parseTransformValue(useLegacyParsing, value);
         if (!parsedTransformValue)
             return nullptr;
 
-        list->append(parsedTransformValue.release());
+        list->append(*parsedTransformValue);
     }
 
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTransformValue(bool useLegacyParsing, CSSParserValue *value)
+NullableCSSValue CSSPropertyParser::parseTransformValue(bool useLegacyParsing, CSSParserValue *value)
 {
     if (value->unit != CSSParserValue::Function || !value->function)
         return nullptr;
 
     // Every primitive requires at least one argument.
     CSSParserValueList* args = value->function->args.get();
     if (!args)
         return nullptr;
 
     // See if the specified primitive is one we understand.
@@ skipping 51 matching lines @@
         if (!isComma(a))
             return nullptr;
         a = args->next();
 
         argNumber++;
     }
 
     return transformValue.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseMotionPath()
+NullableCSSValue CSSPropertyParser::parseMotionPath()
 {
     CSSParserValue* value = m_valueList->current();
 
     // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
     if (value->unit != CSSParserValue::Function || value->function->id != CSSValuePath)
         return nullptr;
 
     // FIXME: Add support for <fill-rule>.
     CSSParserValueList* functionArgs = value->function->args.get();
     if (!functionArgs || functionArgs->size() != 1 || !functionArgs->current())
         return nullptr;
 
     CSSParserValue* arg = functionArgs->current();
     if (arg->unit != CSSPrimitiveValue::CSS_STRING)
         return nullptr;
 
     String pathString = arg->string;
     Path path;
     if (!buildPathFromString(pathString, path))
         return nullptr;
 
     m_valueList->next();
     return CSSPathValue::create(pathString);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseMotionRotation()
+NullableCSSValue CSSPropertyParser::parseMotionRotation()
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     bool hasAutoOrReverse = false;
     bool hasAngle = false;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if ((value->id == CSSValueAuto || value->id == CSSValueReverse) && !hasAutoOrReverse) {
             list->append(cssValuePool().createIdentifierValue(value->id));
             hasAutoOrReverse = true;
         } else if (validUnit(value, FAngle) && !hasAngle) {
             list->append(createPrimitiveNumericValue(value));
             hasAngle = true;
         } else {
             break;
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink