Oilpan: Unship Oilpan from CSSValues

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 57 matching lines @@
 template <unsigned N>
 static bool equalIgnoringCase(const CSSParserString& a, const char (&b)[N])
 {
     unsigned length = N - 1; // Ignore the trailing null character
     if (a.length() != length)
         return false;
 
     return a.is8Bit() ? WTF::equalIgnoringCase(b, a.characters8(), length) : WTF::equalIgnoringCase(b, a.characters16(), length);
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createPrimitiveValuePair(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> first, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
+static PassRefPtr<CSSPrimitiveValue> createPrimitiveValuePair(PassRefPtr<CSSPrimitiveValue> first, PassRefPtr<CSSPrimitiveValue> second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
 {
     return cssValuePool().createValue(Pair::create(first, second, identicalValuesPolicy));
 }
 
 CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList,
-    const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,
+    const CSSParserContext& context, Vector<CSSProperty, 256>& parsedProperties,
     StyleRule::Type ruleType)
     : m_valueList(valueList)
     , m_context(context)
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
 {
 }
 
 bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
     CSSParserValueList* valueList, const CSSParserContext& context,
-    WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
+    Vector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
 {
     int parsedPropertiesSize = parsedProperties.size();
 
     CSSPropertyParser parser(valueList, context, parsedProperties, ruleType);
     CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);
     bool parseSuccess;
 
     if (ruleType == StyleRule::Viewport) {
         parseSuccess = (RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(context.mode()))
             && parser.parseViewportProperty(resolvedProperty, important);
     } else if (ruleType == StyleRule::FontFace) {
         parseSuccess = parser.parseFontFaceDescriptor(resolvedProperty);
     } else {
         parseSuccess = parser.parseValue(unresolvedProperty, important);
     }
 
     // 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, PassRefPtr<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 150 matching lines @@
         return unitflags & FAngle;
     case CSSPrimitiveValue::UnitType::DotsPerPixel:
     case CSSPrimitiveValue::UnitType::DotsPerInch:
     case CSSPrimitiveValue::UnitType::DotsPerCentimeter:
         return unitflags & FResolution;
     default:
         return false;
     }
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveNumericValue(CSSParserValue* value)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveNumericValue(CSSParserValue* value)
 {
     if (m_parsedCalculation) {
         ASSERT(isCalculation(value));
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
     }
 
     ASSERT((value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
         || (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)
         || (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)
         || (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter));
     return cssValuePool().createValue(value->fValue, value->unit());
 }
 
-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
+inline PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
 {
     ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::String);
 }
 
-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
+inline PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
     ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);
     return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::CustomIdentifier);
 }
 
-inline PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
+inline PassRefPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
 {
-    RefPtrWillBeRawPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);
+    RefPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);
     toCSSImageValue(imageValue.get())->setReferrer(m_context.referrer());
     return imageValue;
 }
 
 static inline bool isComma(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == ',';
 }
 
@@ skipping 59 matching lines @@
                 break;
             default:
                 break;
             }
         }
         return true;
     }
     return validUnit(value, FLength | FPercent | FNonNeg | unitless);
 }
 
-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue* value)
+inline PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue* value)
 {
     if (identifier)
         return cssValuePool().createIdentifierValue(identifier);
     if (value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
         return createPrimitiveNumericValue(value);
     if (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)
         return createPrimitiveNumericValue(value);
     if (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)
         return createPrimitiveNumericValue(value);
     if (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter)
         return createPrimitiveNumericValue(value);
     if (value->unit() == CSSPrimitiveValue::UnitType::QuirkyEms)
         return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::UnitType::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, PassRefPtr<CSSValue> prpValue, bool important)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     unsigned shorthandLength = shorthand.length();
     if (!shorthandLength) {
         addProperty(propId, prpValue, important);
         return;
     }
 
-    RefPtrWillBeRawPtr<CSSValue> value = prpValue;
+    RefPtr<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 26 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;
+    RefPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     case CSSPropertySize: // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
         parsedValue = parseSize();
         break;
     case CSSPropertyQuotes: // [<string> <string>]+ | none
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseQuotes();
@@ 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 (!parseValue(CSSPropertyOverflowY, important) || m_valueList->current())
             return false;
 
-        RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;
+        RefPtr<CSSValue> overflowXValue = nullptr;
 
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = m_parsedProperties.last().value();
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
@@ skipping 62 matching lines @@
         break;
 
     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;
+        RefPtr<CSSValueList> list = nullptr;
         while (value) {
-            RefPtrWillBeRawPtr<CSSValue> image = nullptr;
+            RefPtr<CSSValue> image = nullptr;
             if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
                 String uri = value->string;
                 if (!uri.isNull())
                     image = createCSSImageValueWithReferrer(uri, completeURL(uri));
             } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {
                 image = parseImageSet(m_valueList);
                 if (!image)
                     break;
             } else
                 break;
@@ skipping 77 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;
+        RefPtr<CSSValue> val1 = nullptr;
+        RefPtr<CSSValue> val2 = nullptr;
         CSSPropertyID propId1, propId2;
         bool result = false;
         if (parseFillProperty(unresolvedProperty, propId1, propId2, val1, val2)) {
             if (propId == CSSPropertyBackgroundPosition ||
                 propId == CSSPropertyBackgroundRepeat ||
                 propId == CSSPropertyWebkitMaskPosition ||
                 propId == CSSPropertyWebkitMaskRepeat) {
                 ShorthandScope scope(this, propId);
                 addProperty(propId1, val1.release(), important);
                 if (val2)
@@ skipping 210 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)) {
+        if (RefPtr<CSSValue> result = parseBorderImage(propId)) {
             addProperty(propId, result, important);
             return true;
         }
         return false;
     }
 
     case CSSPropertyBorderImageOutset:
     case CSSPropertyWebkitMaskBoxImageOutset: {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
+        RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageRepeat:
     case CSSPropertyWebkitMaskBoxImageRepeat: {
-        RefPtrWillBeRawPtr<CSSValue> result = nullptr;
+        RefPtr<CSSValue> result = nullptr;
         if (parseBorderImageRepeat(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageSlice:
     case CSSPropertyWebkitMaskBoxImageSlice: {
-        RefPtrWillBeRawPtr<CSSBorderImageSliceValue> result = nullptr;
+        RefPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageWidth:
     case CSSPropertyWebkitMaskBoxImageWidth: {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
+        RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageWidth(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderTopRightRadius:
     case CSSPropertyBorderTopLeftRadius:
     case CSSPropertyBorderBottomLeftRadius:
     case CSSPropertyBorderBottomRightRadius: {
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
         if (!validPrimitive)
             return false;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
+        RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
+        RefPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
         value = m_valueList->next();
         if (value) {
             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
             if (!validPrimitive)
                 return false;
             parsedValue2 = createPrimitiveNumericValue(value);
         } else
             parsedValue2 = parsedValue1;
 
         if (m_valueList->next())
             return false;
         addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()), important);
         return true;
     }
     case CSSPropertyTabSize:
         // May be specified as a unit-less non-negative integer or length indicating number of space characters.
         validPrimitive = validUnit(value, FInteger | FLength | FNonNeg);
         break;
     case CSSPropertyBorderRadius:
     case CSSPropertyAliasWebkitBorderRadius:
         return parseBorderRadius(unresolvedProperty, important);
     case CSSPropertyOutlineOffset:
         validPrimitive = validUnit(value, FLength);
         break;
     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
     case CSSPropertyBoxShadow:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
-            RefPtrWillBeRawPtr<CSSValueList> shadowValueList = parseShadow(m_valueList, propId);
+            RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList, propId);
             if (shadowValueList) {
                 addProperty(propId, shadowValueList.release(), important);
                 m_valueList->next();
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyWebkitBoxReflect:
         if (id == CSSValueNone)
@@ skipping 12 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();
+            RefPtr<CSSValue> val = parseFilter();
             if (val) {
                 addProperty(propId, val, important);
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyFlex: {
         ShorthandScope scope(this, propId);
         if (id == CSSValueNone) {
@@ skipping 18 matching lines @@
     case CSSPropertyOrder:
         validPrimitive = validUnit(value, FInteger);
         break;
     case CSSPropertyTransform:
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseTransform(unresolvedProperty == CSSPropertyAliasWebkitTransform);
         break;
     case CSSPropertyTransformOrigin: {
-        RefPtrWillBeRawPtr<CSSValueList> list = parseTransformOrigin();
+        RefPtr<CSSValueList> list = parseTransformOrigin();
         if (!list)
             return false;
         // These values are added to match gecko serialization.
         if (list->length() == 1)
             list->append(cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
         if (list->length() == 2)
             list->append(cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels));
         addProperty(propId, list.release(), important);
         return true;
     }
 
     case CSSPropertyTranslate: {
         // translate : [ <length> | <percentage> ] [[ <length> | <percentage> ] <length>? ]?
         // defaults to 0 on all axis, note that the last value CANNOT be a percentage
         ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
-        RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
         if (!validUnit(value, FLength | FPercent))
             return false;
 
         list->append(createPrimitiveNumericValue(value));
         value = m_valueList->next();
 
         if (value) {
             if (!validUnit(value, FLength | FPercent))
                 return false;
 
             list->append(createPrimitiveNumericValue(value));
             value = m_valueList->next();
 
             if (value) {
                 if (!validUnit(value, FLength))
                     return false;
 
                 list->append(createPrimitiveNumericValue(value));
                 value = m_valueList->next();
             }
         }
 
         parsedValue = list.release();
         break;
     }
 
     case CSSPropertyRotate: { // rotate : <angle> <number>{3}? defaults to a 0 0 1
         ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
-        RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
         if (!validUnit(value, FAngle))
             return false;
         list->append(createPrimitiveNumericValue(value));
         value = m_valueList->next();
 
         if (!value) {
             parsedValue = list.release();
             break;
         }
 
         for (unsigned i = 0; i < 3; i++) { // 3 dimensions of rotation
             if (!value || !validUnit(value, FNumber))
                 return false;
             list->append(createPrimitiveNumericValue(value));
             value = m_valueList->next();
         }
 
         parsedValue = list.release();
         break;
     }
 
     case CSSPropertyScale: { // scale: <number>{1,3}, default scale for all axis is 1
         ASSERT(RuntimeEnabledFeatures::cssIndependentTransformPropertiesEnabled());
-        RefPtrWillBeRawPtr<CSSValueList> scaleList = CSSValueList::createSpaceSeparated();
+        RefPtr<CSSValueList> scaleList = CSSValueList::createSpaceSeparated();
 
         for (unsigned i = 0; value && i < 3; i++) { // up to 3 dimensions of scale
             if (!validUnit(value, FNumber))
                 return false;
             scaleList->append(createPrimitiveNumericValue(value));
             value = m_valueList->next();
         }
 
         parsedValue = scaleList.release();
         break;
@@ skipping 20 matching lines @@
         } else if (validUnit(value, FLength) && (m_parsedCalculation || value->fValue > 0)) {
             validPrimitive = true;
         } else if (unresolvedProperty == CSSPropertyAliasWebkitPerspective && validUnit(value, FNumber) && value->fValue > 0) {
             value->setUnit(CSSPrimitiveValue::UnitType::Pixels);
             validPrimitive = true;
         } else {
             return false;
         }
         break;
     case CSSPropertyPerspectiveOrigin: {
-        RefPtrWillBeRawPtr<CSSValueList> list = parseTransformOrigin();
+        RefPtr<CSSValueList> list = parseTransformOrigin();
         if (!list || list->length() == 3)
             return false;
         // This values are added to match gecko serialization.
         if (list->length() == 1)
             list->append(cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
         addProperty(propId, list.release(), important);
         return true;
     }
 
     case CSSPropertyMotion:
@@ skipping 361 matching lines @@
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
             addProperty(propId, parsedValue.release(), important);
             return true;
         }
     }
     return false;
 }
 
-void CSSPropertyParser::addFillValue(RefPtrWillBeRawPtr<CSSValue>& lval, PassRefPtrWillBeRawPtr<CSSValue> rval)
+void CSSPropertyParser::addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
 {
     if (lval) {
         if (lval->isBaseValueList())
             toCSSValueList(lval.get())->append(rval);
         else {
-            PassRefPtrWillBeRawPtr<CSSValue> oldlVal(lval.release());
-            PassRefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+            PassRefPtr<CSSValue> oldlVal(lval.release());
+            PassRefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             list->append(oldlVal);
             list->append(rval);
             lval = list;
         }
     }
     else
         lval = rval;
 }
 
-static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtrWillBeRawPtr<CSSValue>& cssValue)
+static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtr<CSSValue>& cssValue)
 {
     if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
         || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {
         cssValue = cssValuePool().createIdentifierValue(parserValue->id);
         return true;
     }
     return false;
 }
 
 const int cMaxFillProperties = 9;
 
 bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)
 {
     ASSERT(numProperties <= cMaxFillProperties);
     if (numProperties > cMaxFillProperties)
         return false;
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[cMaxFillProperties] = { false };
-    RefPtrWillBeRawPtr<CSSValue> values[cMaxFillProperties];
+    RefPtr<CSSValue> values[cMaxFillProperties];
 #if ENABLE(OILPAN)
     // Zero initialize the array of raw pointers.
     memset(&values, 0, sizeof(values));
 #endif
-    RefPtrWillBeRawPtr<CSSValue> clipValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> positionYValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> repeatYValue = nullptr;
+    RefPtr<CSSValue> clipValue = nullptr;
+    RefPtr<CSSValue> positionYValue = nullptr;
+    RefPtr<CSSValue> repeatYValue = nullptr;
     bool foundClip = false;
     int i;
     bool foundPositionCSSProperty = false;
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (isComma(val)) {
             // We hit the end.  Fill in all remaining values with the initial value.
             m_valueList->next();
             for (i = 0; i < numProperties; ++i) {
@@ 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;
+                RefPtr<CSSValue> val1 = nullptr;
+                RefPtr<CSSValue> val2 = nullptr;
                 CSSPropertyID propId1, propId2;
                 CSSParserValue* parserValue = m_valueList->current();
                 // parseFillProperty() may modify m_implicitShorthand, so we MUST reset it
                 // before EACH return below.
                 if (parserValue && parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
                     parsedProperty[i] = found = true;
                     addFillValue(values[i], val1.release());
                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
                         addFillValue(positionYValue, val2.release());
                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
@@ skipping 95 matching lines @@
 
     // The list of properties in the shorthand should be the same
     // length as the list with animation name in last position, even though they are
     // in a different order.
     ASSERT(numProperties == animationProperties.length());
     ASSERT(numProperties == animationShorthand().length());
 
     ShorthandScope scope(this, CSSPropertyAnimation);
 
     bool parsedProperty[numProperties] = { false };
-    RefPtrWillBeRawPtr<CSSValueList> values[numProperties];
+    RefPtr<CSSValueList> values[numProperties];
     for (size_t i = 0; i < numProperties; ++i)
         values[i] = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         if (consumeComma(m_valueList)) {
             // We hit the end. Fill in all remaining values with the initial value.
             for (size_t i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
                     values[i]->append(cssValuePool().createImplicitInitialValue());
                 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 (RefPtr<CSSValue> val = parseAnimationProperty(animationProperties.properties()[i], useLegacyparsing)) {
                 parsedProperty[i] = found = true;
                 values[i]->append(val.release());
                 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 12 matching lines @@
 
 bool CSSPropertyParser::parseTransitionShorthand(bool important)
 {
     const unsigned numProperties = 4;
     const StylePropertyShorthand& shorthand = transitionShorthandForParsing();
     ASSERT(numProperties == shorthand.length());
 
     ShorthandScope scope(this, CSSPropertyTransition);
 
     bool parsedProperty[numProperties] = { false };
-    RefPtrWillBeRawPtr<CSSValueList> values[numProperties];
+    RefPtr<CSSValueList> values[numProperties];
     for (size_t i = 0; i < numProperties; ++i)
         values[i] = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         if (consumeComma(m_valueList)) {
             // We hit the end. Fill in all remaining values with the initial value.
             for (size_t i = 0; i < numProperties; ++i) {
                 if (!parsedProperty[i])
                     values[i]->append(cssValuePool().createImplicitInitialValue());
                 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 (RefPtr<CSSValue> val = parseAnimationProperty(shorthand.properties()[i], false)) {
                 parsedProperty[i] = found = true;
                 values[i]->append(val.release());
                 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()
+PassRefPtr<CSSValue> 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);
+        RefPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
         m_valueList->next();
         return parsedValue;
     }
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColumnCount()
+PassRefPtr<CSSValue> CSSPropertyParser::parseColumnCount()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto || validUnit(value, FPositiveInteger)) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = parseValidPrimitive(value->id, value);
+        RefPtr<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;
+    RefPtr<CSSValue> columnWidth = nullptr;
+    RefPtr<CSSValue> columnCount = nullptr;
     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 136 matching lines @@
             break;
         }
         default: {
             return false;
         }
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapPoints()
+PassRefPtr<CSSValue> CSSPropertyParser::parseScrollSnapPoints()
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     if (value->m_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) && (m_parsedCalculation || repeatValue->fValue > 0)) {
-            RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
+            RefPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueRepeat);
             result->append(parseValidPrimitive(repeatValue->id, repeatValue));
             m_valueList->next();
             return result.release();
         }
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
+PassRefPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
 {
     if (m_valueList->current()->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     return parsePositionList(m_valueList);
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parsePage()
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parsePage()
 {
     CSSParserValue* value = m_valueList->current();
     m_valueList->next();
     ASSERT(value);
 
     if (value->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(value->id);
     if (value->m_unit == CSSParserValue::Identifier)
         return createPrimitiveCustomIdentValue(value);
     return nullptr;
 }
 
 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseSize()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseSize()
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
 
-    RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
 
     // First parameter.
     SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None);
     if (paramType == None)
         return nullptr;
     value = m_valueList->next();
 
     // Second parameter, if any.
     if (value) {
         paramType = parseSizeParameter(parsedValues.get(), value, paramType);
@@ skipping 40 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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseQuotes()
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+        RefPtr<CSSValue> parsedValue = nullptr;
         if (val->unit() != CSSPrimitiveValue::UnitType::String)
             return nullptr;
         parsedValue = createPrimitiveStringValue(val);
         values->append(parsedValue.release());
         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()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseContent()
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
 
     while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+        RefPtr<CSSValue> parsedValue = nullptr;
         if (val->unit() == CSSPrimitiveValue::UnitType::URI) {
             // url
             parsedValue = createCSSImageValueWithReferrer(val->string, completeURL(val->string));
         } else if (val->m_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 24 matching lines @@
         }
         if (!parsedValue)
             return nullptr;
         values->append(parsedValue.release());
         m_valueList->next();
     }
 
     return values.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAttr(CSSParserValueList* args)
+PassRefPtr<CSSValue> CSSPropertyParser::parseAttr(CSSParserValueList* args)
 {
     if (args->size() != 1)
         return nullptr;
 
     CSSParserValue* a = args->current();
 
     if (a->m_unit != CSSParserValue::Identifier)
         return nullptr;
 
     String attrName = a->string;
@@ skipping 50 matching lines @@
     //   '-internal-inactive-list-box-selection'
     //   '-internal-inactive-list-box-selection-text'
     //   '-webkit-focus-ring-color'
     //   '-webkit-text'
     //
     return (id >= CSSValueAqua && id <= CSSValueWebkitText)
         || (id >= CSSValueAliceblue && id <= CSSValueYellowgreen)
         || id == CSSValueMenu;
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseColor(const CSSParserValue* value, bool acceptQuirkyColors)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseColor(const CSSParserValue* value, bool acceptQuirkyColors)
 {
     CSSValueID id = value->id;
     if (isColorKeyword(id)) {
         if (!isValueAllowedInMode(id, m_context.mode()))
             return nullptr;
         return cssValuePool().createIdentifierValue(id);
     }
     RGBA32 c = Color::transparent;
     if (!parseColorFromValue(value, c, acceptQuirkyColors))
         return nullptr;
     return cssValuePool().createColorValue(c);
 }
 
-bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value)
+bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtr<CSSValue>& value)
 {
     if (valueList->current()->id == CSSValueNone) {
         value = cssValuePool().createIdentifierValue(CSSValueNone);
         return true;
     }
     if (valueList->current()->unit() == CSSPrimitiveValue::UnitType::URI) {
         value = createCSSImageValueWithReferrer(valueList->current()->string, completeURL(valueList->current()->string));
         return true;
     }
 
     if (isGeneratedImageValue(valueList->current()))
         return parseGeneratedImage(valueList, value);
 
     if (valueList->current()->m_unit == CSSParserValue::Function && valueList->current()->function->id == CSSValueWebkitImageSet) {
         value = parseImageSet(m_valueList);
         if (value)
             return true;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionX(CSSParserValueList* valueList)
+PassRefPtr<CSSValue> 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::UnitType::Percentage);
     }
     if (validUnit(valueList->current(), FPercent | FLength))
         return createPrimitiveNumericValue(valueList->current());
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillPositionY(CSSParserValueList* valueList)
+PassRefPtr<CSSValue> 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::UnitType::Percentage);
     }
     if (validUnit(valueList->current(), FPercent | FLength))
         return createPrimitiveNumericValue(valueList->current());
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode parsingMode, Units unitless)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag, FillPositionParsingMode parsingMode, Units unitless)
 {
     CSSValueID id = valueList->current()->id;
     if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) {
         int percent = 0;
         if (id == CSSValueLeft || id == CSSValueRight) {
             if (cumulativeFlags & XFillPosition)
                 return nullptr;
             cumulativeFlags |= XFillPosition;
             individualFlag = XFillPosition;
             if (id == CSSValueRight)
@@ skipping 44 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, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<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);
+    RefPtr<CSSPrimitiveValue> value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
     if (!value3)
         return;
 
     CSSValueID ident1 = parsedValue1->getValueID();
     CSSValueID ident3 = value3->getValueID();
 
     if (ident1 == CSSValueCenter)
         return;
 
     if (!isFillPositionKeyword(ident3) || ident3 == CSSValueCenter)
         return;
 
     // We need to check if the values are not conflicting, e.g. they are not on the same edge. It is
     // needed as the second call to parseFillPositionComponent was on purpose not checking it. In the
     // case of two values top 20px is invalid but in the case of 4 values it becomes valid.
     if (isValueConflictingWithCurrentEdge(ident1, ident3))
         return;
 
     valueList->next();
 
     cumulativeFlags = 0;
     FillPositionFlag value4Flag = InvalidFillPosition;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> value4 = parseFillPositionComponent(valueList, cumulativeFlags, value4Flag, ResolveValuesAsKeyword);
+    RefPtr<CSSPrimitiveValue> value4 = parseFillPositionComponent(valueList, cumulativeFlags, value4Flag, ResolveValuesAsKeyword);
     if (!value4)
         return;
 
     // 4th value must be a length or a percentage.
     if (isFillPositionKeyword(value4->getValueID()))
         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, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2, PassRefPtr<CSSPrimitiveValue> parsedValue1, PassRefPtr<CSSPrimitiveValue> parsedValue2)
 {
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
+    RefPtr<CSSPrimitiveValue> value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
 
     // value3 is not an expected value, we return.
     if (!value3)
         return;
 
     valueList->next();
 
     bool swapNeeded = false;
     CSSValueID ident1 = parsedValue1->getValueID();
     CSSValueID ident2 = parsedValue2->getValueID();
@@ skipping 23 matching lines @@
             return;
 
         secondPositionKeyword = CSSValueTop;
         if (ident1 == CSSValueTop || ident1 == CSSValueBottom) {
             secondPositionKeyword = CSSValueLeft;
             swapNeeded = true;
         }
         value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
         value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
     } else {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> firstPositionValue = nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> secondPositionValue = nullptr;
+        RefPtr<CSSPrimitiveValue> firstPositionValue = nullptr;
+        RefPtr<CSSPrimitiveValue> secondPositionValue = nullptr;
 
         if (isFillPositionKeyword(ident2)) {
             // To match CSS grammar, we should only accept: [ center | left | right | bottom | top ] [ left | right | top | bottom ] [ <percentage> | <length> ].
             ASSERT(ident2 != CSSValueCenter);
 
             if (isFillPositionKeyword(ident3))
                 return;
 
             secondPositionValue = value3;
             secondPositionKeyword = ident2;
@@ skipping 26 matching lines @@
     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, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& 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 26 matching lines @@
     // a valid start for <position>.
     cumulativeFlags = AmbiguousFillPosition;
     value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag, ResolveValuesAsKeyword);
     if (value2)
         valueList->next();
     else {
         value1.clear();
         return;
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = toCSSPrimitiveValue(value1.get());
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = toCSSPrimitiveValue(value2.get());
+    RefPtr<CSSPrimitiveValue> parsedValue1 = toCSSPrimitiveValue(value1.get());
+    RefPtr<CSSPrimitiveValue> parsedValue2 = toCSSPrimitiveValue(value2.get());
 
     value1.clear();
     value2.clear();
 
     // 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());
     else
         parse4ValuesFillPosition(valueList, value1, value2, parsedValue1.release(), parsedValue2.release());
 }
 
-void CSSPropertyParser::parse2ValuesFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, Units unitless)
+void CSSPropertyParser::parse2ValuesFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& 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
@@ skipping 22 matching lines @@
         // 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::UnitType::Percentage);
     }
 
     if (value1Flag == YFillPosition || value2Flag == XFillPosition)
         value1.swap(value2);
 }
 
-void CSSPropertyParser::parseFillRepeat(RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2)
+void CSSPropertyParser::parseFillRepeat(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& 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 20 matching lines @@
             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());
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseFillSize(CSSPropertyID unresolvedProperty)
+PassRefPtr<CSSValue> 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;
+    RefPtr<CSSPrimitiveValue> parsedValue1 = nullptr;
 
     if (value->id == CSSValueAuto)
         parsedValue1 = cssValuePool().createIdentifierValue(CSSValueAuto);
     else {
         if (!validUnit(value, FLength | FPercent))
             return nullptr;
         parsedValue1 = createPrimitiveNumericValue(value);
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
+    RefPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
     value = m_valueList->current();
     if (value) {
         if (value->id == CSSValueAuto) {
             // `auto' is the default
             m_valueList->next();
         } else if (validUnit(value, FLength | FPercent)) {
             parsedValue2 = createPrimitiveNumericValue(value);
             m_valueList->next();
         }
     } else if (unresolvedProperty == CSSPropertyAliasWebkitBackgroundSize) {
         // For backwards compatibility we set the second value to the first if it is omitted.
         // We only need to do this for -webkit-background-size. It should be safe to let masks match
         // the real property.
         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)
+    RefPtr<CSSValue>& retValue1, RefPtr<CSSValue>& 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;
+    RefPtr<CSSValueList> values = nullptr;
+    RefPtr<CSSValueList> values2 = nullptr;
+    RefPtr<CSSValue> value = nullptr;
+    RefPtr<CSSValue> value2 = nullptr;
 
     retValue1 = 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;
+        RefPtr<CSSValue> currValue = nullptr;
+        RefPtr<CSSValue> currValue2 = nullptr;
 
         Units unitless = FUnknown;
         CSSParserValue* val = m_valueList->current();
         ASSERT(val);
 
         switch (propId) {
         case CSSPropertyBackgroundColor:
             currValue = parseColor(val);
             if (currValue)
                 m_valueList->next();
@@ skipping 141 matching lines @@
         }
     } else {
         ASSERT(value);
         retValue1 = value.release();
         retValue2 = value2.release();
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDelay()
+PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationDelay()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime))
         return createPrimitiveNumericValue(value);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationDirection()
+PassRefPtr<CSSValue> 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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationDuration()
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FTime | FNonNeg))
         return createPrimitiveNumericValue(value);
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationFillMode()
+PassRefPtr<CSSValue> 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()
+PassRefPtr<CSSValue> 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)
+PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationName(bool allowQuotedName)
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     if (value->m_unit == CSSParserValue::Identifier)
         return createPrimitiveCustomIdentValue(value);
 
     if (allowQuotedName && value->unit() == CSSPrimitiveValue::UnitType::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()
+PassRefPtr<CSSValue> 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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationProperty()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->m_unit != CSSParserValue::Identifier)
         return nullptr;
     CSSPropertyID property = unresolvedCSSPropertyID(value->string);
     if (property) {
         ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
         return cssValuePool().createIdentifierValue(property);
     }
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (value->id == CSSValueInitial || value->id == CSSValueInherit)
         return nullptr;
     return createPrimitiveCustomIdentValue(value);
 }
 
 bool CSSPropertyParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result)
 {
     CSSParserValue* v = args->current();
     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()
+PassRefPtr<CSSValue> 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->m_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)
+PassRefPtr<CSSValue> CSSPropertyParser::parseAnimationProperty(CSSPropertyID propId, bool useLegacyParsing)
 {
-    RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+    RefPtr<CSSValue> value = nullptr;
     switch (propId) {
     case CSSPropertyAnimationDelay:
     case CSSPropertyTransitionDelay:
         value = parseAnimationDelay();
         break;
     case CSSPropertyAnimationDirection:
         value = parseAnimationDirection();
         break;
     case CSSPropertyAnimationDuration:
     case CSSPropertyTransitionDuration:
@@ skipping 21 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 
     if (value)
         m_valueList->next();
     return value.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseAnimationPropertyList(CSSPropertyID propId, bool useLegacyParsing)
+PassRefPtr<CSSValueList> CSSPropertyParser::parseAnimationPropertyList(CSSPropertyID propId, bool useLegacyParsing)
 {
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     while (true) {
-        RefPtrWillBeRawPtr<CSSValue> value = parseAnimationProperty(propId, useLegacyParsing);
+        RefPtr<CSSValue> value = parseAnimationProperty(propId, useLegacyParsing);
         if (!value)
             return nullptr;
         list->append(value.release());
         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();
 }
 
 static inline bool isCSSWideKeyword(const CSSParserValue& value)
 {
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueUnset || value.id == CSSValueDefault;
 }
 
 static inline bool isValidCustomIdentForGridPositions(const CSSParserValue& value)
 {
     // FIXME: we need a more general solution for <custom-ident> in all properties.
     return value.m_unit == CSSParserValue::Identifier && value.id != CSSValueSpan && value.id != CSSValueAuto && !isCSSWideKeyword(value);
 }
 
 // The function parses [ <integer> || <custom-ident> ] in <grid-line> (which can be stand alone or with 'span').
-bool CSSPropertyParser::parseIntegerOrCustomIdentFromGridPosition(RefPtrWillBeRawPtr<CSSPrimitiveValue>& numericValue, RefPtrWillBeRawPtr<CSSPrimitiveValue>& gridLineName)
+bool CSSPropertyParser::parseIntegerOrCustomIdentFromGridPosition(RefPtr<CSSPrimitiveValue>& numericValue, RefPtr<CSSPrimitiveValue>& gridLineName)
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FInteger) && value->fValue) {
         numericValue = createPrimitiveNumericValue(value);
         value = m_valueList->next();
         if (value && isValidCustomIdentForGridPositions(*value)) {
             gridLineName = createPrimitiveCustomIdentValue(m_valueList->current());
             m_valueList->next();
         }
         return true;
     }
 
     if (isValidCustomIdentForGridPositions(*value)) {
         gridLineName = createPrimitiveCustomIdentValue(m_valueList->current());
         value = m_valueList->next();
         if (value && validUnit(value, FInteger) && value->fValue) {
             numericValue = createPrimitiveNumericValue(value);
             m_valueList->next();
         }
         return true;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridPosition()
+PassRefPtr<CSSValue> 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;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> gridLineName = nullptr;
+    RefPtr<CSSPrimitiveValue> numericValue = nullptr;
+    RefPtr<CSSPrimitiveValue> gridLineName = nullptr;
     bool hasSeenSpanKeyword = false;
 
     if (parseIntegerOrCustomIdentFromGridPosition(numericValue, gridLineName)) {
         value = m_valueList->current();
         if (value && value->id == CSSValueSpan) {
             hasSeenSpanKeyword = true;
             m_valueList->next();
         }
     } else if (value->id == CSSValueSpan) {
         hasSeenSpanKeyword = true;
@@ skipping 13 matching lines @@
         return nullptr;
 
     // Negative numbers are not allowed for span (but are for <integer>).
     if (hasSeenSpanKeyword && numericValue && numericValue->getIntValue() < 0)
         return nullptr;
 
     // For the <custom-ident> case.
     if (gridLineName && !numericValue && !hasSeenSpanKeyword)
         return cssValuePool().createValue(gridLineName->getStringValue(), CSSPrimitiveValue::UnitType::CustomIdentifier);
 
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     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 PassRefPtr<CSSValue> gridMissingGridPositionValue(CSSValue* value)
 {
     if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->isCustomIdent())
         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();
+    RefPtr<CSSValue> startValue = parseGridPosition();
     if (!startValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> endValue = nullptr;
+    RefPtr<CSSValue> endValue = nullptr;
     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());
     }
 
     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(PassRefPtr<CSSValue> templateColumns, bool important)
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
     bool trailingIdentWasAdded = false;
-    RefPtrWillBeRawPtr<CSSValueList> templateRows = CSSValueList::createSpaceSeparated();
+    RefPtr<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))
             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::UnitType::String) {
-            RefPtrWillBeRawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            RefPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return false;
             templateRows->append(value);
         } else {
             templateRows->append(cssValuePool().createIdentifierValue(CSSValueAuto));
         }
 
         // This will handle the trailing/leading <custom-ident>* in the grammar.
         if (!parseGridLineNames(*m_valueList, *templateRows))
             return false;
         trailingIdentWasAdded = templateRows->item(templateRows->length() - 1)->isGridLineNamesValue();
     }
 
     // [<track-list> /]?
     if (templateColumns)
         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);
+    RefPtr<CSSValue> templateAreas = CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
     addProperty(CSSPropertyGridTemplateAreas, templateAreas.release(), 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;
+    RefPtr<CSSValue> columnsValue = nullptr;
     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 (RefPtr<CSSValue> rowsValue = parseGridTrackList()) {
             if (m_valueList->current())
                 return false;
             addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
             addProperty(CSSPropertyGridTemplateRows, rowsValue, important);
             addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
             return true;
         }
     }
 
 
@@ skipping 21 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;
+    RefPtr<CSSValue> autoColumnsValue = nullptr;
+    RefPtr<CSSValue> autoRowsValue = nullptr;
 
     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)
@@ skipping 24 matching lines @@
 }
 
 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();
+    RefPtr<CSSValue> rowStartValue = parseGridPosition();
     if (!rowStartValue)
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnStartValue = nullptr;
+    RefPtr<CSSValue> columnStartValue = nullptr;
     if (!parseSingleGridAreaLonghand(columnStartValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> rowEndValue = nullptr;
+    RefPtr<CSSValue> rowEndValue = nullptr;
     if (!parseSingleGridAreaLonghand(rowEndValue))
         return false;
 
-    RefPtrWillBeRawPtr<CSSValue> columnEndValue = nullptr;
+    RefPtr<CSSValue> columnEndValue = nullptr;
     if (!parseSingleGridAreaLonghand(columnEndValue))
         return false;
 
     if (!columnStartValue)
         columnStartValue = gridMissingGridPositionValue(rowStartValue.get());
 
     if (!rowEndValue)
         rowEndValue = gridMissingGridPositionValue(rowStartValue.get());
 
     if (!columnEndValue)
         columnEndValue = gridMissingGridPositionValue(columnStartValue.get());
 
     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(RefPtr<CSSValue>& 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.m_unit == CSSParserValue::Operator && value.iValue == ']';
 }
 
 bool CSSPropertyParser::parseGridLineNames(CSSParserValueList& inputList, CSSValueList& valueList, CSSGridLineNamesValue* previousNamedAreaTrailingLineNames)
 {
     if (!inputList.current() || inputList.current()->m_unit != CSSParserValue::Operator || inputList.current()->iValue != '[')
         return true;
 
     // Skip '['
     inputList.next();
 
-    RefPtrWillBeRawPtr<CSSGridLineNamesValue> lineNames = previousNamedAreaTrailingLineNames;
+    RefPtr<CSSGridLineNamesValue> lineNames = 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);
+        RefPtr<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()
+PassRefPtr<CSSValue> 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();
+    RefPtr<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->m_unit == CSSParserValue::Function && currentValue->function->id == CSSValueRepeat) {
             if (!parseGridTrackRepeatFunction(*values))
                 return nullptr;
             seenTrackSizeOrRepeatFunction = true;
         } else {
-            RefPtrWillBeRawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
+            RefPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return nullptr;
             values->append(value);
             seenTrackSizeOrRepeatFunction = true;
         }
         // This will handle the trailing <custom-ident>* in the grammar.
         if (!parseGridLineNames(*m_valueList, *values))
             return nullptr;
     }
 
     // We should have found a <track-size> or else it is not a valid <track-list>
     if (!seenTrackSizeOrRepeatFunction)
         return nullptr;
 
     return values;
 }
 
 bool CSSPropertyParser::parseGridTrackRepeatFunction(CSSValueList& list)
 {
     CSSParserValueList* arguments = m_valueList->current()->function->args.get();
     if (!arguments || arguments->size() < 3 || !validUnit(arguments->valueAt(0), FPositiveInteger) || !isComma(arguments->valueAt(1)))
         return false;
 
     ASSERT(arguments->valueAt(0)->fValue > 0);
     size_t repetitions = clampTo<size_t>(arguments->valueAt(0)->fValue, 0, kGridMaxTracks);
 
-    RefPtrWillBeRawPtr<CSSValueList> repeatedValues = CSSValueList::createSpaceSeparated();
+    RefPtr<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);
+        RefPtr<CSSValue> trackSize = parseGridTrackSize(*arguments);
         if (!trackSize)
             return false;
 
         repeatedValues->append(trackSize);
         ++numberOfTracks;
 
         // This takes care of any trailing <custom-ident>* in the grammar.
         if (!parseGridLineNames(*arguments, *repeatedValues))
             return false;
     }
@@ skipping 10 matching lines @@
         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)
+PassRefPtr<CSSValue> CSSPropertyParser::parseGridTrackSize(CSSParserValueList& inputList)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* currentValue = inputList.current();
     inputList.next();
 
     if (currentValue->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (currentValue->m_unit == CSSParserValue::Function && currentValue->function->id == CSSValueMinmax) {
         // The spec defines the following grammar: minmax( <track-breadth> , <track-breadth> )
         CSSParserValueList* arguments = currentValue->function->args.get();
         if (!arguments || arguments->size() != 3 || !isComma(arguments->valueAt(1)))
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(arguments->valueAt(0));
+        RefPtr<CSSPrimitiveValue> minTrackBreadth = parseGridBreadth(arguments->valueAt(0));
         if (!minTrackBreadth)
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
+        RefPtr<CSSPrimitiveValue> maxTrackBreadth = parseGridBreadth(arguments->valueAt(2));
         if (!maxTrackBreadth)
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueMinmax);
+        RefPtr<CSSFunctionValue> result = CSSFunctionValue::create(CSSValueMinmax);
         result->append(minTrackBreadth);
         result->append(maxTrackBreadth);
         return result.release();
     }
 
     return parseGridBreadth(currentValue);
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseGridBreadth(CSSParserValue* currentValue)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseGridBreadth(CSSParserValue* currentValue)
 {
     if (currentValue->id == CSSValueMinContent || currentValue->id == CSSValueMaxContent || currentValue->id == CSSValueAuto)
         return cssValuePool().createIdentifierValue(currentValue->id);
 
     if (currentValue->unit() == CSSPrimitiveValue::UnitType::Fraction) {
         double flexValue = currentValue->fValue;
 
         // Fractional unit is a non-negative dimension.
         if (flexValue <= 0)
             return nullptr;
@@ skipping 100 matching lines @@
 
             ++gridCoordinate.rows.resolvedFinalPosition;
         }
         currentCol = lookAheadCol;
     }
 
     m_valueList->next();
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseGridTemplateAreas()
+PassRefPtr<CSSValue> 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)
+PassRefPtr<CSSValue> CSSPropertyParser::parseGridAutoFlow(CSSParserValueList& list)
 {
     // [ row | column ] || dense
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = list.current();
     if (!value)
         return nullptr;
 
-    RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
 
     // First parameter.
     CSSValueID firstId = value->id;
     if (firstId != CSSValueRow && firstId != CSSValueColumn && firstId != CSSValueDense)
         return nullptr;
     parsedValues->append(cssValuePool().createIdentifierValue(firstId));
 
     // Second parameter, if any.
     value = list.next();
     if (value) {
@@ skipping 10 matching lines @@
         default:
             return parsedValues;
         }
         parsedValues->append(cssValuePool().createIdentifierValue(value->id));
         list.next();
     }
 
     return parsedValues;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
+PassRefPtr<CSSValue> 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->m_unit != CSSParserValue::Identifier)
         return nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = createPrimitiveCustomIdentValue(i);
+    RefPtr<CSSPrimitiveValue> identifier = createPrimitiveCustomIdentValue(i);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = nullptr;
+    RefPtr<CSSPrimitiveValue> separator = nullptr;
     if (!counters)
         separator = cssValuePool().createValue(String(), CSSPrimitiveValue::UnitType::CustomIdentifier);
     else {
         args->next();
         if (!consumeComma(args))
             return nullptr;
 
         i = args->current();
         if (i->unit() != CSSPrimitiveValue::UnitType::String)
             return nullptr;
 
         separator = createPrimitiveCustomIdentValue(i);
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = nullptr;
+    RefPtr<CSSPrimitiveValue> listStyle = nullptr;
     i = args->next();
     if (!i) // Make the list style default decimal
         listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
     else {
         if (!consumeComma(args))
             return nullptr;
 
         i = args->current();
         if (i->m_unit != CSSParserValue::Identifier)
             return nullptr;
 
         CSSValueID listStyleID = CSSValueInvalid;
         if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha))
             listStyleID = i->id;
         else
             return nullptr;
 
         listStyle = cssValuePool().createIdentifierValue(listStyleID);
     }
 
     return CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release());
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseClipShape()
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseClipShape()
 {
     CSSParserValue* value = m_valueList->current();
     CSSParserValueList* args = value->function->args.get();
 
     if (value->function->id != CSSValueRect || !args)
         return nullptr;
 
     // rect(t, r, b, l) || rect(t r b l)
     if (args->size() != 4 && args->size() != 7)
         return nullptr;
-    RefPtrWillBeRawPtr<Rect> rect = Rect::create();
+    RefPtr<Rect> rect = Rect::create();
     int i = 0;
     CSSParserValue* a = args->current();
     while (a) {
         if (a->id != CSSValueAuto && !validUnit(a, FLength | FUnitlessQuirk))
             return nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> length = a->id == CSSValueAuto ?
+        RefPtr<CSSPrimitiveValue> length = a->id == CSSValueAuto ?
             cssValuePool().createIdentifierValue(CSSValueAuto) :
             createPrimitiveNumericValue(a);
         if (i == 0)
             rect->setTop(length);
         else if (i == 1)
             rect->setRight(length);
         else if (i == 2)
             rect->setBottom(length);
         else
             rect->setLeft(length);
         a = args->next();
         if (a && args->size() == 7) {
             if (!consumeComma(args))
                 return nullptr;
             a = args->current();
         }
         i++;
     }
     m_valueList->next();
     return cssValuePool().createValue(rect.release());
 }
 
-static void completeBorderRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[4])
+static void completeBorderRadii(RefPtr<CSSPrimitiveValue> radii[4])
 {
     if (radii[3])
         return;
     if (!radii[2]) {
         if (!radii[1])
             radii[1] = radii[0];
         radii[2] = radii[0];
     }
     radii[3] = radii[1];
 }
 
 // FIXME: This should be refactored with parseBorderRadius.
 // parseBorderRadius contains support for some legacy radius construction.
-PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseInsetRoundedCorners(PassRefPtrWillBeRawPtr<CSSBasicShapeInset> shape, CSSParserValueList* args)
+PassRefPtr<CSSBasicShape> CSSPropertyParser::parseInsetRoundedCorners(PassRefPtr<CSSBasicShapeInset> shape, CSSParserValueList* args)
 {
     CSSParserValue* argument = args->next();
 
     if (!argument)
         return nullptr;
 
     Vector<CSSParserValue*> radiusArguments;
     while (argument) {
         radiusArguments.append(argument);
         argument = args->next();
     }
 
     unsigned num = radiusArguments.size();
     if (!num || num > 9)
         return nullptr;
 
     // FIXME: Refactor completeBorderRadii and the array
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[2][4];
+    RefPtr<CSSPrimitiveValue> radii[2][4];
 #if ENABLE(OILPAN)
     // Zero initialize the array of raw pointers.
     memset(&radii, 0, sizeof(radii));
 #endif
 
     unsigned indexAfterSlash = 0;
     for (unsigned i = 0; i < num; ++i) {
         CSSParserValue* value = radiusArguments.at(i);
         if (value->m_unit == CSSParserValue::Operator) {
             if (value->iValue != '/')
                 return nullptr;
 
             if (!i || indexAfterSlash || i + 1 == num)
                 return nullptr;
 
             indexAfterSlash = i + 1;
             completeBorderRadii(radii[0]);
             continue;
         }
 
         if (i - indexAfterSlash >= 4)
             return nullptr;
 
         if (!validUnit(value, FLength | FPercent | FNonNeg))
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
+        RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
 
         if (!indexAfterSlash)
             radii[0][i] = radius;
         else
             radii[1][i - indexAfterSlash] = radius.release();
     }
 
     if (!indexAfterSlash) {
         completeBorderRadii(radii[0]);
         for (unsigned i = 0; i < 4; ++i)
             radii[1][i] = radii[0][i];
     } else {
         completeBorderRadii(radii[1]);
     }
     shape->setTopLeftRadius(createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()));
     shape->setTopRightRadius(createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()));
     shape->setBottomRightRadius(createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()));
     shape->setBottomLeftRadius(createPrimitiveValuePair(radii[0][3].release(), radii[1][3].release()));
 
     return shape;
 }
 
-PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeInset(CSSParserValueList* args)
+PassRefPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeInset(CSSParserValueList* args)
 {
     ASSERT(args);
 
-    RefPtrWillBeRawPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
+    RefPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
 
     CSSParserValue* argument = args->current();
-    WillBeHeapVector<RefPtrWillBeMember<CSSPrimitiveValue>> widthArguments;
+    WillBeHeapVector<RefPtr<CSSPrimitiveValue>> widthArguments;
     bool hasRoundedInset = false;
 
     while (argument) {
         if (argument->m_unit == CSSParserValue::Identifier && argument->id == CSSValueRound) {
             hasRoundedInset = true;
             break;
         }
 
         Units unitFlags = FLength | FPercent;
         if (!validUnit(argument, unitFlags) || widthArguments.size() > 4)
@@ skipping 76 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()
+PassRefPtr<CSSValue> 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 46 matching lines @@
     ASSERT(value);
 
     if (value->id == CSSValueAuto || value->id == CSSValueStretch || isBaselinePositionKeyword(value->id)) {
         if (m_valueList->next())
             return false;
 
         addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
         return true;
     }
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> position = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> overflowAlignmentKeyword = nullptr;
+    RefPtr<CSSPrimitiveValue> position = nullptr;
+    RefPtr<CSSPrimitiveValue> overflowAlignmentKeyword = nullptr;
     if (isItemPositionKeyword(value->id)) {
         position = cssValuePool().createIdentifierValue(value->id);
         value = m_valueList->next();
         if (value) {
             if (isAlignmentOverflowKeyword(value->id))
                 overflowAlignmentKeyword = cssValuePool().createIdentifierValue(value->id);
             else
                 return false;
         }
     } else if (isAlignmentOverflowKeyword(value->id)) {
@@ skipping 12 matching lines @@
 
     ASSERT(position);
     if (overflowAlignmentKeyword)
         addProperty(propId, createPrimitiveValuePair(position, overflowAlignmentKeyword), important);
     else
         addProperty(propId, position.release(), important);
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CSSParserValue* value)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CSSParserValue* value)
 {
     if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide)
         return cssValuePool().createIdentifierValue(value->id);
 
     if (!validUnit(value, FLength | FPercent | FNonNeg))
         return nullptr;
 
     return createPrimitiveNumericValue(value);
 }
 
-PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeCircle(CSSParserValueList* args)
+PassRefPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeCircle(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // circle(radius)
     // circle(radius at <position>)
     // circle(at <position>)
     // where position defines centerX and centerY using a CSS <position> data type.
-    RefPtrWillBeRawPtr<CSSBasicShapeCircle> shape = CSSBasicShapeCircle::create();
+    RefPtr<CSSBasicShapeCircle> shape = CSSBasicShapeCircle::create();
 
     for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
         // The call to parseFillPosition below should consume all of the
         // arguments except the first two. Thus, and index greater than one
         // indicates an invalid production.
         if (args->currentIndex() > 1)
             return nullptr;
 
         if (!args->currentIndex() && argument->id != CSSValueAt) {
-            if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
+            if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 shape->setRadius(radius);
                 continue;
             }
 
             return nullptr;
         }
 
         if (argument->id == CSSValueAt && args->next()) {
-            RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
-            RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
+            RefPtr<CSSValue> centerX = nullptr;
+            RefPtr<CSSValue> centerY = nullptr;
             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()));
             } else {
                 return nullptr;
             }
         } else {
             return nullptr;
         }
     }
 
     return shape;
 }
 
-PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(CSSParserValueList* args)
+PassRefPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeEllipse(CSSParserValueList* args)
 {
     ASSERT(args);
 
     // ellipse(radiusX)
     // ellipse(radiusX at <position>)
     // ellipse(radiusX radiusY)
     // ellipse(radiusX radiusY at <position>)
     // ellipse(at <position>)
     // where position defines centerX and centerY using a CSS <position> data type.
-    RefPtrWillBeRawPtr<CSSBasicShapeEllipse> shape = CSSBasicShapeEllipse::create();
+    RefPtr<CSSBasicShapeEllipse> shape = CSSBasicShapeEllipse::create();
 
     for (CSSParserValue* argument = args->current(); argument; argument = args->next()) {
         // The call to parseFillPosition below should consume all of the
         // arguments except the first three. Thus, an index greater than two
         // indicates an invalid production.
         if (args->currentIndex() > 2)
             return nullptr;
 
         if (args->currentIndex() < 2 && argument->id != CSSValueAt) {
-            if (RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
+            if (RefPtr<CSSPrimitiveValue> radius = parseShapeRadius(argument)) {
                 if (!shape->radiusX())
                     shape->setRadiusX(radius);
                 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;
+        RefPtr<CSSValue> centerX = nullptr;
+        RefPtr<CSSValue> centerY = nullptr;
         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()));
     }
 
     return shape;
 }
 
-PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(CSSParserValueList* args)
+PassRefPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(CSSParserValueList* args)
 {
     ASSERT(args);
 
     unsigned size = args->size();
     if (!size)
         return nullptr;
 
-    RefPtrWillBeRawPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::create();
+    RefPtr<CSSBasicShapePolygon> shape = CSSBasicShapePolygon::create();
 
     CSSParserValue* argument = args->current();
     if (argument->id == CSSValueEvenodd || argument->id == CSSValueNonzero) {
         shape->setWindRule(argument->id == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO);
         args->next();
 
         if (!consumeComma(args))
             return nullptr;
 
         size -= 2;
     }
 
     // <length> <length>, ... <length> <length> -> each pair has 3 elements except the last one
     if (!size || (size % 3) - 2)
         return nullptr;
 
     while (true) {
         CSSParserValue* argumentX = args->current();
         if (!argumentX || !validUnit(argumentX, FLength | FPercent))
             return nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(argumentX);
+        RefPtr<CSSPrimitiveValue> xLength = createPrimitiveNumericValue(argumentX);
 
         CSSParserValue* argumentY = args->next();
         if (!argumentY || !validUnit(argumentY, FLength | FPercent))
             return nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(argumentY);
+        RefPtr<CSSPrimitiveValue> yLength = createPrimitiveNumericValue(argumentY);
 
         shape->appendPoint(xLength.release(), yLength.release());
 
         if (!args->next())
             break;
         if (!consumeComma(args))
             return nullptr;
     }
 
     return shape;
 }
 
 static bool isBoxValue(CSSValueID valueId)
 {
     switch (valueId) {
     case CSSValueContentBox:
     case CSSValuePaddingBox:
     case CSSValueBorderBox:
     case CSSValueMarginBox:
         return true;
     default:
         break;
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
+PassRefPtr<CSSValue> CSSPropertyParser::parseShapeProperty(CSSPropertyID propId)
 {
-    RefPtrWillBeRawPtr<CSSValue> imageValue = nullptr;
+    RefPtr<CSSValue> imageValue = nullptr;
     if (parseFillImage(m_valueList, imageValue)) {
         m_valueList->next();
         return imageValue.release();
     }
 
     return parseBasicShapeAndOrBox();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBasicShapeAndOrBox()
+PassRefPtr<CSSValue> CSSPropertyParser::parseBasicShapeAndOrBox()
 {
     CSSParserValue* value = m_valueList->current();
 
     bool shapeFound = false;
     bool boxFound = false;
     CSSValueID valueId;
 
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (unsigned i = 0; i < 2; ++i) {
         if (!value)
             break;
         valueId = value->id;
         if (value->m_unit == CSSParserValue::Function && !shapeFound) {
             // parseBasicShape already asks for the next value list item.
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = parseBasicShape();
+            RefPtr<CSSPrimitiveValue> shapeValue = parseBasicShape();
             if (!shapeValue)
                 return nullptr;
             list->append(shapeValue.release());
             shapeFound = true;
         } else if (isBoxValue(valueId) && !boxFound) {
             list->append(parseValidPrimitive(valueId, value));
             boxFound = true;
             m_valueList->next();
         } else {
             return nullptr;
         }
 
         value = m_valueList->current();
     }
 
     if (m_valueList->current())
         return nullptr;
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape()
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseBasicShape()
 {
     CSSParserValue* value = m_valueList->current();
     ASSERT(value->m_unit == CSSParserValue::Function);
     CSSParserValueList* args = value->function->args.get();
 
     if (!args)
         return nullptr;
 
-    RefPtrWillBeRawPtr<CSSBasicShape> shape = nullptr;
+    RefPtr<CSSBasicShape> shape = nullptr;
     if (value->function->id == CSSValueCircle)
         shape = parseBasicShapeCircle(args);
     else if (value->function->id == CSSValueEllipse)
         shape = parseBasicShapeEllipse(args);
     else if (value->function->id == CSSValuePolygon)
         shape = parseBasicShapePolygon(args);
     else if (value->function->id == CSSValueInset)
         shape = parseBasicShapeInset(args);
 
     if (!shape)
@@ skipping 57 matching lines @@
 
     value = m_valueList->current();
     if (!value)
         return false;
 
     if (isForwardSlashOperator(value)) {
         // The line-height property.
         value = m_valueList->next();
         if (!value)
             return false;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> lineHeight = parseLineHeight();
+        RefPtr<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();
+    RefPtr<CSSValue> parsedFamilyValue = parseFontFamily();
     if (!parsedFamilyValue)
         return false;
 
     addProperty(CSSPropertyFontFamily, parsedFamilyValue.release(), 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;
@@ skipping 11 matching lines @@
     FontStyle fontStyle = FontStyleNormal;
     FontWeight fontWeight = FontWeightNormal;
     float fontSize = 0;
     AtomicString fontFamily;
     LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, fontFamily);
 
     ShorthandScope scope(this, CSSPropertyFont);
     addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
     addProperty(CSSPropertyFontWeight, cssValuePool().createValue(fontWeight), important);
     addProperty(CSSPropertyFontSize, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
-    RefPtrWillBeRawPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
     fontFamilyList->append(cssValuePool().createFontFamilyValue(fontFamily));
     addProperty(CSSPropertyFontFamily, fontFamilyList.release(), important);
 
     addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     return true;
 }
 
 class FontFamilyValueBuilder {
@@ skipping 20 matching lines @@
     void commit()
     {
         if (m_builder.isEmpty())
             return;
         m_list->append(cssValuePool().createFontFamilyValue(m_builder.toString()));
         m_builder.clear();
     }
 
 private:
     StringBuilder m_builder;
-    RawPtrWillBeMember<CSSValueList> m_list;
+    RawPtr<CSSValueList> m_list;
 };
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFamily()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseFontFamily()
 {
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     CSSParserValue* value = m_valueList->current();
 
     FontFamilyValueBuilder familyBuilder(list.get());
     bool inFamily = false;
 
     while (value) {
         CSSParserValue* nextValue = m_valueList->next();
         bool nextValBreaksFont = !nextValue || isComma(nextValue);
         bool nextValIsFontName = nextValue &&
             ((nextValue->id >= CSSValueSerif && nextValue->id <= CSSValueWebkitBody) ||
@@ skipping 48 matching lines @@
             value = nextValue;
         else
             break;
     }
     familyBuilder.commit();
     if (!list->length() || (m_ruleType == StyleRule::FontFace && list->length() > 1))
         list = nullptr;
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseLineHeight()
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseLineHeight()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
 
     // normal | <number> | <length> | <percentage> | inherit
     if (id == CSSValueNormal) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(id);
     }
 
@@ skipping 19 matching lines @@
         validPrimitive = true;
     else
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg | (inShorthand() ? FUnknown : FUnitlessQuirk));
     if (validPrimitive && (!m_valueList->next() || inShorthand()))
         addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value), important);
     return validPrimitive;
 }
 
 bool CSSPropertyParser::parseFontVariant(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
+    RefPtr<CSSValueList> values = nullptr;
     if (m_valueList->size() > 1)
         values = CSSValueList::createCommaSeparated();
     bool expectComma = false;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue = nullptr;
+        RefPtr<CSSPrimitiveValue> parsedValue = nullptr;
         if (!expectComma) {
             expectComma = true;
             if (val->id == CSSValueNormal || val->id == CSSValueSmallCaps)
                 parsedValue = cssValuePool().createIdentifierValue(val->id);
             else if (val->id == CSSValueAll && !values) {
                 // FIXME: CSSPropertyParser::parseFontVariant() implements
                 // the old css3 draft:
                 // http://www.w3.org/TR/2002/WD-css3-webfonts-20020802/#font-variant
                 // 'all' is only allowed in @font-face and with no other values. Make a value list to
                 // indicate that we are in the @font-face case.
@@ skipping 40 matching lines @@
         if (!(weight % 100) && weight >= 100 && weight <= 900) {
             addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1)), important);
             return true;
         }
     }
     return false;
 }
 
 bool CSSPropertyParser::parseFontFaceSrcURI(CSSValueList* valueList)
 {
-    RefPtrWillBeRawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string), m_context.shouldCheckContentSecurityPolicy()));
+    RefPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string), m_context.shouldCheckContentSecurityPolicy()));
     uriValue->setReferrer(m_context.referrer());
 
     CSSParserValue* value = m_valueList->next();
     if (!value || value->m_unit != CSSParserValue::Function || value->function->id != CSSValueFormat) {
         valueList->append(uriValue.release());
         return true;
     }
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20111004/ says that format() contains a comma-separated list of strings,
     // but CSSFontFaceSrcValue stores only one format. Allowing one format for now.
@@ skipping 25 matching lines @@
                 builder.append(' ');
             builder.append(localValue->string);
         }
         valueList->append(CSSFontFaceSrcValue::createLocal(builder.toString(), shouldCheckContentSecurityPolicy));
     } else
         return false;
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFaceSrc()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseFontFaceSrc()
 {
-    RefPtrWillBeRawPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
+    RefPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
 
     while (true) {
         CSSParserValue* value = m_valueList->current();
         if (!value)
             return nullptr;
         if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
             if (!parseFontFaceSrcURI(values.get()))
                 return nullptr;
         } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueLocal) {
             if (!parseFontFaceSrcLocal(values.get()))
                 return nullptr;
         } else {
             return nullptr;
         }
 
         if (!m_valueList->current())
             return values.release();
         if (!consumeComma(m_valueList))
             return nullptr;
     }
 }
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFaceUnicodeRange()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseFontFaceUnicodeRange()
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
 
     do {
         CSSParserValue* current = m_valueList->current();
         if (!current || current->m_unit != CSSParserValue::UnicodeRange)
             return nullptr;
 
         UChar32 start = current->m_unicodeRange.start;
         UChar32 end = current->m_unicodeRange.end;
         if (start > end)
             return nullptr;
@@ skipping 221 matching lines @@
 
         allowX = true;
         allowColor = true;
         allowBreak = true;
         allowY = false;
         allowBlur = false;
         allowSpread = false;
         allowStyle = property == CSSPropertyBoxShadow;
     }
 
-    void commitLength(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
+    void commitLength(PassRefPtr<CSSPrimitiveValue> val)
     {
         if (allowX) {
             x = val;
             allowX = false;
             allowY = true;
             allowColor = false;
             allowStyle = false;
             allowBreak = false;
         } else if (allowY) {
             y = val;
             allowY = false;
             allowBlur = true;
             allowColor = true;
             allowStyle = property == CSSPropertyBoxShadow;
             allowBreak = true;
         } else if (allowBlur) {
             blur = val;
             allowBlur = false;
             allowSpread = property == CSSPropertyBoxShadow;
         } else if (allowSpread) {
             spread = val;
             allowSpread = false;
         }
     }
 
-    void commitColor(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
+    void commitColor(PassRefPtr<CSSPrimitiveValue> val)
     {
         color = val;
         allowColor = false;
         if (allowX) {
             allowStyle = false;
             allowBreak = false;
         } else {
             allowBlur = false;
             allowSpread = false;
             allowStyle = property == CSSPropertyBoxShadow;
         }
     }
 
     void commitStyle(CSSParserValue* v)
     {
         style = cssValuePool().createIdentifierValue(v->id);
         allowStyle = false;
         if (allowX)
             allowBreak = false;
         else {
             allowBlur = false;
             allowSpread = false;
             allowColor = false;
         }
     }
 
     CSSPropertyID property;
 
-    RefPtrWillBeMember<CSSValueList> values;
-    RefPtrWillBeMember<CSSPrimitiveValue> x;
-    RefPtrWillBeMember<CSSPrimitiveValue> y;
-    RefPtrWillBeMember<CSSPrimitiveValue> blur;
-    RefPtrWillBeMember<CSSPrimitiveValue> spread;
-    RefPtrWillBeMember<CSSPrimitiveValue> style;
-    RefPtrWillBeMember<CSSPrimitiveValue> color;
+    RefPtr<CSSValueList> values;
+    RefPtr<CSSPrimitiveValue> x;
+    RefPtr<CSSPrimitiveValue> y;
+    RefPtr<CSSPrimitiveValue> blur;
+    RefPtr<CSSPrimitiveValue> spread;
+    RefPtr<CSSPrimitiveValue> style;
+    RefPtr<CSSPrimitiveValue> color;
 
     bool allowX;
     bool allowY;
     bool allowBlur;
     bool allowSpread;
     bool allowColor;
     bool allowStyle; // inset or not.
     bool allowBreak;
 };
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseShadow(CSSParserValueList* valueList, CSSPropertyID propId)
+PassRefPtr<CSSValueList> CSSPropertyParser::parseShadow(CSSParserValueList* valueList, CSSPropertyID propId)
 {
     ShadowParseContext context(propId);
     for (CSSParserValue* val = valueList->current(); val; val = valueList->next()) {
         // Check for a comma break first.
         if (val->m_unit == CSSParserValue::Operator) {
             if (val->iValue != ',' || !context.allowBreak) {
                 // Other operators aren't legal or we aren't done with the current shadow
                 // value.  Treat as invalid.
                 return nullptr;
             }
             // The value is good.  Commit it.
             context.commitValue();
         } else if (validUnit(val, FLength, HTMLStandardMode)) {
             // We required a length and didn't get one. Invalid.
             if (!context.allowLength())
                 return nullptr;
 
             // Blur radius must be non-negative.
             if (context.allowBlur && (m_parsedCalculation ? m_parsedCalculation->isNegative() : !validUnit(val, FLength | FNonNeg, HTMLStandardMode)))
                 return nullptr;
 
             // A length is allowed here.  Construct the value and add it.
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(val);
+            RefPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(val);
             context.commitLength(length.release());
         } else if (val->id == CSSValueInset) {
             if (!context.allowStyle)
                 return nullptr;
 
             context.commitStyle(val);
         } else {
             if (!context.allowColor)
                 return nullptr;
 
             // The only other type of value that's ok is a color value.
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor = parseColor(val);
+            RefPtr<CSSPrimitiveValue> parsedColor = parseColor(val);
             if (!parsedColor)
                 return nullptr;
 
             context.commitColor(parsedColor.release());
         }
     }
 
     if (context.allowBreak) {
         context.commitValue();
         if (context.values && context.values->length())
             return context.values.release();
     }
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseReflect()
+PassRefPtr<CSSValue> CSSPropertyParser::parseReflect()
 {
     // box-reflect: <direction> <offset> <mask>
 
     // Direction comes first.
     CSSParserValue* val = m_valueList->current();
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> direction = nullptr;
+    RefPtr<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;
+    RefPtr<CSSPrimitiveValue> offset = nullptr;
     if (!val)
         offset = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
     else {
         if (!validUnit(val, FLength | FPercent))
             return nullptr;
         offset = createPrimitiveNumericValue(val);
     }
 
     // Now for the mask.
-    RefPtrWillBeRawPtr<CSSValue> mask = nullptr;
+    RefPtr<CSSValue> mask = nullptr;
     val = m_valueList->next();
     if (val) {
         mask = parseBorderImage(CSSPropertyWebkitBoxReflect);
         if (!mask)
             return nullptr;
     }
 
     return CSSReflectValue::create(direction.release(), offset.release(), mask.release());
 }
 
 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)
         return false;
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> flexBasis = nullptr;
+    RefPtr<CSSPrimitiveValue> flexBasis = nullptr;
 
     while (CSSParserValue* arg = args->current()) {
         if (validUnit(arg, FNumber | FNonNeg)) {
             if (flexGrow == unsetValue)
                 flexGrow = arg->fValue;
             else if (flexShrink == unsetValue)
                 flexShrink = arg->fValue;
             else if (!arg->fValue) {
                 // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
                 flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
@@ skipping 16 matching lines @@
         flexShrink = 1;
     if (!flexBasis)
         flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
 
     addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::Number), important);
     addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::Number), important);
     addProperty(CSSPropertyFlexBasis, flexBasis, important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parsePosition(CSSParserValueList* valueList)
+PassRefPtr<CSSValue> CSSPropertyParser::parsePosition(CSSParserValueList* valueList)
 {
-    RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
+    RefPtr<CSSValue> xValue = nullptr;
+    RefPtr<CSSValue> yValue = nullptr;
     parseFillPosition(valueList, xValue, yValue);
     if (!xValue || !yValue)
         return nullptr;
     return createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues);
 }
 
 // Parses a list of comma separated positions. i.e., <position>#
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parsePositionList(CSSParserValueList* valueList)
+PassRefPtr<CSSValueList> CSSPropertyParser::parsePositionList(CSSParserValueList* valueList)
 {
-    RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
+    RefPtr<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);
+        RefPtr<CSSValue> position = parsePosition(valueList);
         if (!position)
             return nullptr;
         positions->append(position);
 
         if (!valueList->current())
             break;
         if (!consumeComma(valueList) || !valueList->current())
             return nullptr;
     }
 
@@ skipping 19 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(PassRefPtr<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;
     }
-    void commitImageSlice(PassRefPtrWillBeRawPtr<CSSBorderImageSliceValue> slice)
+    void commitImageSlice(PassRefPtr<CSSBorderImageSliceValue> slice)
     {
         m_imageSlice = slice;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowForwardSlashOperator = true;
         m_allowImageSlice = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
     }
     void commitForwardSlashOperator()
     {
         m_canAdvance = true;
         m_allowCommit = false;
         m_allowImage = false;
         m_allowImageSlice = false;
         m_allowRepeat = false;
         if (!m_borderWidth && !m_allowWidth) {
             m_allowForwardSlashOperator = true;
             m_allowWidth = true;
             m_requireOutset = false;
         } else {
             m_allowForwardSlashOperator = false;
             m_requireOutset = true;
             m_allowWidth = false;
         }
     }
-    void commitBorderWidth(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> width)
+    void commitBorderWidth(PassRefPtr<CSSPrimitiveValue> width)
     {
         m_borderWidth = width;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowForwardSlashOperator = true;
         m_allowImageSlice = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
     }
-    void commitBorderOutset(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> outset)
+    void commitBorderOutset(PassRefPtr<CSSPrimitiveValue> outset)
     {
         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(PassRefPtr<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()
+    PassRefPtr<CSSValue> commitCSSValue()
     {
         return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat.get());
     }
 
     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;
-    RefPtrWillBeMember<CSSBorderImageSliceValue> m_imageSlice;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_borderWidth;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_outset;
+    RefPtr<CSSValue> m_image;
+    RefPtr<CSSBorderImageSliceValue> m_imageSlice;
+    RefPtr<CSSPrimitiveValue> m_borderWidth;
+    RefPtr<CSSPrimitiveValue> m_outset;
 
-    RefPtrWillBeMember<CSSValue> m_repeat;
+    RefPtr<CSSValue> 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::UnitType::URI) {
                 context.commitImage(createCSSImageValueWithReferrer(val->string, m_context.completeURL(val->string)));
             } else if (isGeneratedImageValue(val)) {
-                RefPtrWillBeRawPtr<CSSValue> value = nullptr;
+                RefPtr<CSSValue> value = nullptr;
                 if (parseGeneratedImage(m_valueList, value))
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->m_unit == CSSParserValue::Function && val->function->id == CSSValueWebkitImageSet) {
-                RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
+                RefPtr<CSSValue> value = parseImageSet(m_valueList);
                 if (value)
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->id == CSSValueNone)
                 context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
         }
 
         if (!context.canAdvance() && context.allowImageSlice()) {
-            RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
+            RefPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
             if (parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
         if (!context.canAdvance() && context.allowRepeat()) {
-            RefPtrWillBeRawPtr<CSSValue> repeat = nullptr;
+            RefPtr<CSSValue> repeat = nullptr;
             if (parseBorderImageRepeat(repeat))
                 context.commitRepeat(repeat.release());
         }
 
         if (!context.canAdvance() && context.allowWidth()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderWidth = nullptr;
+            RefPtr<CSSPrimitiveValue> borderWidth = nullptr;
             if (parseBorderImageWidth(borderWidth))
                 context.commitBorderWidth(borderWidth.release());
         }
 
         if (!context.canAdvance() && context.requireOutset()) {
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset = nullptr;
+            RefPtr<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, PassRefPtr<CSSValue> value, bool important)
 {
     if (value)
         addProperty(propId, value, important);
     else
         addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
 }
 
 bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId, bool important)
 {
     BorderImageParseContext context;
@@ skipping 14 matching lines @@
             commitBorderImageProperty(CSSPropertyBorderImageRepeat, context.m_repeat, important);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
+PassRefPtr<CSSValue> 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(RefPtr<CSSValue>& result)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> firstValue = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> secondValue = nullptr;
+    RefPtr<CSSPrimitiveValue> firstValue = nullptr;
+    RefPtr<CSSPrimitiveValue> secondValue = nullptr;
     CSSParserValue* val = m_valueList->current();
     if (!val)
         return false;
     if (isBorderImageRepeatKeyword(val->id))
         firstValue = cssValuePool().createIdentifierValue(val->id);
     else
         return false;
 
     val = m_valueList->next();
     if (val) {
@@ skipping 23 matching lines @@
     , m_allowFill(true)
     , m_allowFinalCommit(false)
     , m_fill(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFill() const { return m_allowFill; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
     CSSPrimitiveValue* top() const { return m_top.get(); }
 
-    void commitNumber(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
+    void commitNumber(PassRefPtr<CSSPrimitiveValue> val)
     {
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
         }
 
         m_allowNumber = !m_left;
         m_allowFinalCommit = true;
     }
 
     void commitFill() { m_fill = true; m_allowFill = false; m_allowNumber = !m_top; }
 
-    PassRefPtrWillBeRawPtr<CSSBorderImageSliceValue> commitBorderImageSlice()
+    PassRefPtr<CSSBorderImageSliceValue> commitBorderImageSlice()
     {
         // We need to clone and repeat values for any omissions.
         ASSERT(m_top);
         if (!m_right) {
             m_right = m_top;
             m_bottom = m_top;
             m_left = m_top;
         }
         if (!m_bottom) {
             m_bottom = m_top;
             m_left = m_right;
         }
         if (!m_left)
             m_left = m_right;
 
         // Now build a rect value to hold all four of our primitive values.
-        RefPtrWillBeRawPtr<Quad> quad = Quad::create();
+        RefPtr<Quad> quad = Quad::create();
         quad->setTop(m_top);
         quad->setRight(m_right);
         quad->setBottom(m_bottom);
         quad->setLeft(m_left);
 
         // Make our new border image value now.
         return CSSBorderImageSliceValue::create(cssValuePool().createValue(quad.release()), m_fill);
     }
 
 private:
     bool m_allowNumber;
     bool m_allowFill;
     bool m_allowFinalCommit;
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_top;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_right;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_left;
+    RefPtr<CSSPrimitiveValue> m_top;
+    RefPtr<CSSPrimitiveValue> m_right;
+    RefPtr<CSSPrimitiveValue> m_bottom;
+    RefPtr<CSSPrimitiveValue> m_left;
 
     bool m_fill;
 };
 
-bool CSSPropertyParser::parseBorderImageSlice(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSBorderImageSliceValue>& result)
+bool CSSPropertyParser::parseBorderImageSlice(CSSPropertyID propId, RefPtr<CSSBorderImageSliceValue>& result)
 {
     BorderImageSliceParseContext context;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->next()) {
         // FIXME calc() http://webkit.org/b/16662 : calc is parsed but values are not created yet.
         if (context.allowNumber() && !isCalculation(val) && validUnit(val, FInteger | FNonNeg | FPercent)) {
             context.commitNumber(createPrimitiveNumericValue(val));
         } else if (context.allowFill() && val->id == CSSValueFill) {
             context.commitFill();
         } else if (!inShorthand()) {
             // If we're not parsing a shorthand then we are invalid.
@@ skipping 26 matching lines @@
 public:
     BorderImageQuadParseContext()
     : m_allowNumber(true)
     , m_allowFinalCommit(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
     CSSPrimitiveValue* top() const { return m_top.get(); }
 
-    void commitNumber(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
+    void commitNumber(PassRefPtr<CSSPrimitiveValue> val)
     {
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
         }
 
         m_allowNumber = !m_left;
         m_allowFinalCommit = true;
     }
 
-    void setTop(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val) { m_top = val; }
+    void setTop(PassRefPtr<CSSPrimitiveValue> val) { m_top = val; }
 
-    PassRefPtrWillBeRawPtr<CSSPrimitiveValue> commitBorderImageQuad()
+    PassRefPtr<CSSPrimitiveValue> commitBorderImageQuad()
     {
         // We need to clone and repeat values for any omissions.
         ASSERT(m_top);
         if (!m_right) {
             m_right = m_top;
             m_bottom = m_top;
             m_left = m_top;
         }
         if (!m_bottom) {
             m_bottom = m_top;
             m_left = m_right;
         }
         if (!m_left)
             m_left = m_right;
 
         // Now build a quad value to hold all four of our primitive values.
-        RefPtrWillBeRawPtr<Quad> quad = Quad::create();
+        RefPtr<Quad> quad = Quad::create();
         quad->setTop(m_top);
         quad->setRight(m_right);
         quad->setBottom(m_bottom);
         quad->setLeft(m_left);
 
         // Make our new value now.
         return cssValuePool().createValue(quad.release());
     }
 
 private:
     bool m_allowNumber;
     bool m_allowFinalCommit;
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_top;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_right;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_left;
+    RefPtr<CSSPrimitiveValue> m_top;
+    RefPtr<CSSPrimitiveValue> m_right;
+    RefPtr<CSSPrimitiveValue> m_bottom;
+    RefPtr<CSSPrimitiveValue> m_left;
 };
 
-bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtr<CSSPrimitiveValue>& result)
 {
     BorderImageQuadParseContext context;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->next()) {
         if (context.allowNumber() && (validUnit(val, validUnits, HTMLStandardMode) || val->id == CSSValueAuto)) {
             if (val->id == CSSValueAuto)
                 context.commitNumber(cssValuePool().createIdentifierValue(val->id));
             else
                 context.commitNumber(createPrimitiveNumericValue(val));
         } else if (!inShorthand()) {
             // If we're not parsing a shorthand then we are invalid.
             return false;
         } else {
             if (context.allowFinalCommit())
                 m_valueList->previous(); // The shorthand loop will advance back to this point.
             break;
         }
     }
 
     if (context.allowFinalCommit()) {
         // Need to fully commit as a single value.
         result = context.commitBorderImageQuad();
         return true;
     }
     return false;
 }
 
-bool CSSPropertyParser::parseBorderImageWidth(RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageWidth(RefPtr<CSSPrimitiveValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg | FPercent, result);
 }
 
-bool CSSPropertyParser::parseBorderImageOutset(RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
+bool CSSPropertyParser::parseBorderImageOutset(RefPtr<CSSPrimitiveValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg, result);
 }
 
 bool CSSPropertyParser::parseBorderRadius(CSSPropertyID unresolvedProperty, bool important)
 {
     unsigned num = m_valueList->size();
     if (num > 9)
         return false;
 
     ShorthandScope scope(this, unresolvedProperty);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[2][4];
+    RefPtr<CSSPrimitiveValue> radii[2][4];
 #if ENABLE(OILPAN)
     // Zero initialize the array of raw pointers.
     memset(&radii, 0, sizeof(radii));
 #endif
 
     unsigned indexAfterSlash = 0;
     for (unsigned i = 0; i < num; ++i) {
         CSSParserValue* value = m_valueList->valueAt(i);
         if (value->m_unit == CSSParserValue::Operator) {
             if (value->iValue != '/')
                 return false;
 
             if (!i || indexAfterSlash || i + 1 == num || num > i + 5)
                 return false;
 
             indexAfterSlash = i + 1;
             completeBorderRadii(radii[0]);
             continue;
         }
 
         if (i - indexAfterSlash >= 4)
             return false;
 
         if (!validUnit(value, FLength | FPercent | FNonNeg))
             return false;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
+        RefPtr<CSSPrimitiveValue> radius = createPrimitiveNumericValue(value);
 
         if (!indexAfterSlash) {
             radii[0][i] = radius;
 
             // Legacy syntax: -webkit-border-radius: l1 l2; is equivalent to border-radius: l1 / l2;
             if (num == 2 && unresolvedProperty == CSSPropertyAliasWebkitBorderRadius) {
                 indexAfterSlash = 1;
                 completeBorderRadii(radii[0]);
             }
         } else
             radii[1][i - indexAfterSlash] = radius.release();
     }
 
     if (!indexAfterSlash) {
         completeBorderRadii(radii[0]);
         for (unsigned i = 0; i < 4; ++i)
             radii[1][i] = radii[0][i];
     } else
         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)
+PassRefPtr<CSSValue> CSSPropertyParser::parseCounter(int defaultValue)
 {
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->m_unit != CSSParserValue::Identifier)
             return nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName = createPrimitiveCustomIdentValue(val);
+        RefPtr<CSSPrimitiveValue> counterName = createPrimitiveCustomIdentValue(val);
         m_valueList->next();
 
         val = m_valueList->current();
         int i = defaultValue;
         if (val && validUnit(val, FInteger)) {
             i = clampTo<int>(val->fValue);
             m_valueList->next();
         }
 
         list->append(createPrimitiveValuePair(counterName.release(),
             cssValuePool().createValue(i, CSSPrimitiveValue::UnitType::Number)));
     }
 
     if (!list->length())
         return nullptr;
     return list.release();
 }
 
 // This should go away once we drop support for -webkit-gradient
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal)
+static PassRefPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> result = nullptr;
+    RefPtr<CSSPrimitiveValue> result = nullptr;
     if (a->m_unit == CSSParserValue::Identifier) {
         if ((a->id == CSSValueLeft && horizontal)
             || (a->id == CSSValueTop && !horizontal))
             result = cssValuePool().createValue(0., CSSPrimitiveValue::UnitType::Percentage);
         else if ((a->id == CSSValueRight && horizontal)
             || (a->id == CSSValueBottom && !horizontal))
             result = cssValuePool().createValue(100., CSSPrimitiveValue::UnitType::Percentage);
         else if (a->id == CSSValueCenter)
             result = cssValuePool().createValue(50., CSSPrimitiveValue::UnitType::Percentage);
     } else if (a->unit() == CSSPrimitiveValue::UnitType::Number || a->unit() == CSSPrimitiveValue::UnitType::Percentage) {
         result = cssValuePool().createValue(a->fValue, a->unit());
     }
     return result;
 }
 
 // Used to parse colors for -webkit-gradient(...).
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseDeprecatedGradientStopColor(const CSSParserValue* value)
+PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseDeprecatedGradientStopColor(const CSSParserValue* value)
 {
     // Disallow currentcolor.
     if (value->id == CSSValueCurrentcolor)
         return nullptr;
     return parseColor(value);
 }
 
 bool CSSPropertyParser::parseDeprecatedGradientColorStop(CSSParserValue* a, CSSGradientColorStop& stop)
 {
     if (a->m_unit != CSSParserValue::Function)
@@ skipping 41 matching lines @@
             return false;
 
         stop.m_color = parseDeprecatedGradientStopColor(args->current());
         if (!stop.m_color)
             return false;
     }
 
     return true;
 }
 
-bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient)
+bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtr<CSSValue>& 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->m_unit != CSSParserValue::Identifier)
         return false;
     if (a->id == CSSValueLinear)
         gradientType = CSSDeprecatedLinearGradient;
     else if (a->id == CSSValueRadial)
         gradientType = CSSDeprecatedRadialGradient;
     else
         return false;
 
-    RefPtrWillBeRawPtr<CSSGradientValue> result = nullptr;
+    RefPtr<CSSGradientValue> result = nullptr;
     switch (gradientType) {
     case CSSDeprecatedLinearGradient:
         result = CSSLinearGradientValue::create(NonRepeating, gradientType);
         break;
     case CSSDeprecatedRadialGradient:
         result = CSSRadialGradientValue::create(NonRepeating, gradientType);
         break;
     default:
         // The rest of the gradient types shouldn't appear here.
         ASSERT_NOT_REACHED();
     }
     args->next();
 
     if (!consumeComma(args))
         return false;
 
     // Next comes the starting point for the gradient as an x y pair.  There is no
     // comma between the x and the y values.
     // First X.  It can be left, right, number or percent.
     a = args->current();
     if (!a)
         return false;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> point = parseDeprecatedGradientPoint(a, true);
+    RefPtr<CSSPrimitiveValue> point = parseDeprecatedGradientPoint(a, true);
     if (!point)
         return false;
     result->setFirstX(point.release());
 
     // First Y.  It can be top, bottom, number or percent.
     a = args->next();
     if (!a)
         return false;
     point = parseDeprecatedGradientPoint(a, false);
     if (!point)
@@ skipping 70 matching lines @@
         result->addStop(stop);
 
         // Advance
         a = args->next();
     }
 
     gradient = result.release();
     return true;
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueFromSideKeyword(CSSParserValue* a, bool& isHorizontal)
+static PassRefPtr<CSSPrimitiveValue> valueFromSideKeyword(CSSParserValue* a, bool& isHorizontal)
 {
     if (a->m_unit != CSSParserValue::Identifier)
         return nullptr;
 
     switch (a->id) {
         case CSSValueLeft:
         case CSSValueRight:
             isHorizontal = true;
             break;
         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, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
-    RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSPrefixedLinearGradient);
+    RefPtr<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)
         return false;
 
     bool expectComma = false;
     // Look for angle.
     if (validUnit(a, FAngle, HTMLStandardMode)) {
         result->setAngle(createPrimitiveNumericValue(a));
 
         args->next();
         expectComma = true;
     } else {
         // Look one or two optional keywords that indicate a side or corner.
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> startX = nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> startY = nullptr;
+        RefPtr<CSSPrimitiveValue> startX = nullptr;
+        RefPtr<CSSPrimitiveValue> startY = nullptr;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> location = nullptr;
+        RefPtr<CSSPrimitiveValue> location = nullptr;
         bool isHorizontal = false;
         if ((location = valueFromSideKeyword(a, isHorizontal))) {
             if (isHorizontal)
                 startX = location;
             else
                 startY = location;
 
             a = args->next();
             if (a) {
                 if ((location = valueFromSideKeyword(a, isHorizontal))) {
@@ skipping 24 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, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
-    RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
+    RefPtr<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;
+    RefPtr<CSSValue> centerX = nullptr;
+    RefPtr<CSSValue> centerY = nullptr;
     // 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()));
     // CSS3 radial gradients always share the same start and end point.
     result->setFirstY(toCSSPrimitiveValue(centerY.get()));
     result->setSecondY(toCSSPrimitiveValue(centerY.get()));
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue = nullptr;
+    RefPtr<CSSPrimitiveValue> shapeValue = nullptr;
+    RefPtr<CSSPrimitiveValue> sizeValue = nullptr;
 
     // Optional shape and/or size in any order.
     for (int i = 0; i < 2; ++i) {
         if (a->m_unit != CSSParserValue::Identifier)
             break;
 
         bool foundValue = false;
         switch (a->id) {
         case CSSValueCircle:
         case CSSValueEllipse:
@@ skipping 19 matching lines @@
                 return false;
 
             expectComma = true;
         }
     }
 
     result->setShape(shapeValue);
     result->setSizingBehavior(sizeValue);
 
     // Or, two lengths or percentages
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
+    RefPtr<CSSPrimitiveValue> horizontalSize = nullptr;
+    RefPtr<CSSPrimitiveValue> verticalSize = nullptr;
 
     if (!shapeValue && !sizeValue) {
         if (validUnit(a, FLength | FPercent)) {
             horizontalSize = createPrimitiveNumericValue(a);
             a = args->next();
             if (!a)
                 return false;
 
             expectComma = true;
         }
@@ skipping 15 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, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
-    RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSLinearGradient);
+    RefPtr<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)
         return false;
 
     bool expectComma = false;
     // Look for angle.
     if (validUnit(a, FAngle, HTMLStandardMode)) {
         result->setAngle(createPrimitiveNumericValue(a));
 
         args->next();
         expectComma = true;
     } else if (a->m_unit == CSSParserValue::Identifier && a->id == CSSValueTo) {
         // to [ [left | right] || [top | bottom] ]
         a = args->next();
         if (!a)
             return false;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> endX = nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> endY = nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> location = nullptr;
+        RefPtr<CSSPrimitiveValue> endX = nullptr;
+        RefPtr<CSSPrimitiveValue> endY = nullptr;
+        RefPtr<CSSPrimitiveValue> location = nullptr;
         bool isHorizontal = false;
 
         location = valueFromSideKeyword(a, isHorizontal);
         if (!location)
             return false;
 
         if (isHorizontal)
             endX = location;
         else
             endY = location;
@@ skipping 25 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, RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
-    RefPtrWillBeRawPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
+    RefPtr<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;
 
     bool expectComma = false;
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shapeValue = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> sizeValue = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalSize = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalSize = nullptr;
+    RefPtr<CSSPrimitiveValue> shapeValue = nullptr;
+    RefPtr<CSSPrimitiveValue> sizeValue = nullptr;
+    RefPtr<CSSPrimitiveValue> horizontalSize = nullptr;
+    RefPtr<CSSPrimitiveValue> verticalSize = nullptr;
 
     // First part of grammar, the size/shape clause:
     // [ circle || <length> ] |
     // [ ellipse || [ <length> | <percentage> ]{2} ] |
     // [ [ circle | ellipse] || <size-keyword> ]
     for (int i = 0; i < 3; ++i) {
         if (a->m_unit == CSSParserValue::Identifier) {
             bool badIdent = false;
             switch (a->id) {
             case CSSValueCircle:
@@ skipping 54 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;
+    RefPtr<CSSValue> centerX = nullptr;
+    RefPtr<CSSValue> centerY = nullptr;
     if (a->m_unit == CSSParserValue::Identifier && a->id == CSSValueAt) {
         a = args->next();
         if (!a)
             return false;
 
         parseFillPosition(args, centerX, centerY);
         if (!(centerX && centerY))
             return false;
 
         a = args->current();
@@ skipping 66 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, RefPtr<CSSValue>& value)
 {
     CSSParserValue* val = valueList->current();
 
     if (val->m_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, RefPtr<CSSValue>& 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;
+    RefPtr<CSSValue> fromImageValue = nullptr;
+    RefPtr<CSSValue> toImageValue = nullptr;
 
     // 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.
     if (!args->current() || !parseFillImage(args, toImageValue))
         return false;
     args->next();
 
     if (!consumeComma(args))
         return false;
 
     // The third argument is the crossfade value. It is a percentage or a fractional number.
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> percentage = nullptr;
+    RefPtr<CSSPrimitiveValue> percentage = nullptr;
     CSSParserValue* value = args->current();
     if (!value)
         return false;
 
     if (value->unit() == CSSPrimitiveValue::UnitType::Percentage)
         percentage = cssValuePool().createValue(clampTo<double>(value->fValue / 100, 0, 1), CSSPrimitiveValue::UnitType::Number);
     else if (value->unit() == CSSPrimitiveValue::UnitType::Number)
         percentage = cssValuePool().createValue(clampTo<double>(value->fValue, 0, 1), CSSPrimitiveValue::UnitType::Number);
     else
         return false;
 
-    RefPtrWillBeRawPtr<CSSCrossfadeValue> result = CSSCrossfadeValue::create(fromImageValue, toImageValue);
+    RefPtr<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, RefPtr<CSSValue>& 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->m_unit != CSSParserValue::Identifier)
         return false;
 
     canvas = CSSCanvasValue::create(value->string);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
+PassRefPtr<CSSValue> CSSPropertyParser::parseImageSet(CSSParserValueList* valueList)
 {
     CSSParserValue* function = valueList->current();
 
     if (function->m_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();
+    RefPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
 
     while (functionArgs->current()) {
         CSSParserValue* arg = functionArgs->current();
         if (arg->unit() != CSSPrimitiveValue::UnitType::URI)
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSValue> image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
+        RefPtr<CSSValue> image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
         imageSet->append(image);
 
         arg = functionArgs->next();
         if (!arg)
             return nullptr;
 
         if (arg->m_unit != CSSParserValue::DimensionList)
             return nullptr;
         ASSERT(arg->valueList->valueAt(0)->unit() == CSSPrimitiveValue::UnitType::Number);
         ASSERT(arg->valueList->valueAt(1)->m_unit == CSSParserValue::Identifier);
@@ 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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseWillChange()
 {
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+    RefPtr<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 identifiers is a valid will-change value,
     // unless the list includes an explicitly disallowed identifier.
     while (true) {
         CSSParserValue* currentValue = m_valueList->current();
         if (!currentValue || currentValue->m_unit != CSSParserValue::Identifier)
@@ skipping 27 matching lines @@
 
         if (!m_valueList->next())
             break;
         if (!consumeComma(m_valueList))
             return nullptr;
     }
 
     return values.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSFunctionValue> CSSPropertyParser::parseBuiltinFilterArguments(CSSParserValueList* args, CSSValueID filterType)
+PassRefPtr<CSSFunctionValue> CSSPropertyParser::parseBuiltinFilterArguments(CSSParserValueList* args, CSSValueID filterType)
 {
-    RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
+    RefPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
     ASSERT(args);
 
     switch (filterType) {
     case CSSValueGrayscale:
     case CSSValueSepia:
     case CSSValueSaturate:
     case CSSValueInvert:
     case CSSValueOpacity:
     case CSSValueContrast: {
         // One optional argument, 0-1 or 0%-100%, if missing use 100%.
@@ skipping 48 matching lines @@
             CSSParserValue* argument = args->current();
             if (!validUnit(argument, FLength | FNonNeg, HTMLStandardMode))
                 return nullptr;
 
             filterValue->append(createPrimitiveNumericValue(argument));
         }
         break;
     }
     case CSSValueDropShadow: {
         // drop-shadow() takes a single shadow.
-        RefPtrWillBeRawPtr<CSSValueList> shadowValueList = parseShadow(args, CSSPropertyWebkitFilter);
+        RefPtr<CSSValueList> shadowValueList = parseShadow(args, CSSPropertyWebkitFilter);
         if (!shadowValueList || shadowValueList->length() != 1)
             return nullptr;
 
         filterValue->append((shadowValueList.release())->item(0));
         break;
     }
     default:
         return nullptr;
     }
     return filterValue.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFilter()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseFilter()
 {
     if (!m_valueList)
         return nullptr;
 
     // The filter is a list of functional primitives that specify individual operations.
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit() != CSSPrimitiveValue::UnitType::URI && (value->m_unit != CSSParserValue::Function || !value->function))
             return nullptr;
 
         // See if the specified primitive is one we understand.
         if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
-            RefPtrWillBeRawPtr<CSSFunctionValue> referenceFilterValue = CSSFunctionValue::create(CSSValueUrl);
+            RefPtr<CSSFunctionValue> referenceFilterValue = CSSFunctionValue::create(CSSValueUrl);
             referenceFilterValue->append(CSSSVGDocumentValue::create(value->string));
             list->append(referenceFilterValue.release());
         } else {
             CSSValueID filterType = value->function->id;
             unsigned maximumArgumentCount = filterType == CSSValueDropShadow ? 4 : 1;
 
             CSSParserValueList* args = value->function->args.get();
             if (!args || args->size() > maximumArgumentCount)
                 return nullptr;
 
-            RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = parseBuiltinFilterArguments(args, filterType);
+            RefPtr<CSSFunctionValue> filterValue = parseBuiltinFilterArguments(args, filterType);
             if (!filterValue)
                 return nullptr;
 
             list->append(filterValue);
         }
     }
 
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransformOrigin()
+PassRefPtr<CSSValueList> CSSPropertyParser::parseTransformOrigin()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
-    RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
-    RefPtrWillBeRawPtr<CSSValue> zValue = nullptr;
+    RefPtr<CSSValue> xValue = nullptr;
+    RefPtr<CSSValue> yValue = nullptr;
+    RefPtr<CSSValue> zValue = nullptr;
     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 31 matching lines @@
                 return nullptr;
         }
     } else if (!xValue) {
         if (yValue) {
             xValue = cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage);
         } else {
             xValue = cssValuePool().createIdentifierValue(CSSValueCenter);
         }
     }
 
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     list->append(xValue.release());
     if (yValue)
         list->append(yValue.release());
     if (zValue)
         list->append(zValue.release());
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTouchAction()
+PassRefPtr<CSSValue> CSSPropertyParser::parseTouchAction()
 {
     CSSParserValue* value = m_valueList->current();
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<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);
+            RefPtr<CSSValue> panValue = cssValuePool().createIdentifierValue(value->id);
             list->append(panValue.release());
             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);
+            RefPtr<CSSValue> panValue = cssValuePool().createIdentifierValue(value->id);
             list->append(panValue.release());
             break;
         }
         default:
             return nullptr;
         }
         value = m_valueList->next();
     }
 
     if (list->length())
         return list.release();
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextDecoration()
+PassRefPtr<CSSValue> CSSPropertyParser::parseTextDecoration()
 {
     CSSParserValue* value = m_valueList->current();
     if (value && value->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     bool isValid = true;
     while (isValid && value) {
         switch (value->id) {
         case CSSValueUnderline:
         case CSSValueOverline:
         case CSSValueLineThrough:
         case CSSValueBlink:
             // TODO(timloh): This will incorrectly accept "blink blink"
             list->append(cssValuePool().createIdentifierValue(value->id));
             break;
         default:
             isValid = false;
             break;
         }
         if (isValid)
             value = m_valueList->next();
     }
 
     // Values are either valid or in shorthand scope.
     if (list->length())
         return list.release();
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextEmphasisStyle()
+PassRefPtr<CSSValue> CSSPropertyParser::parseTextEmphasisStyle()
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = nullptr;
+    RefPtr<CSSPrimitiveValue> fill = nullptr;
+    RefPtr<CSSPrimitiveValue> shape = nullptr;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit() == CSSPrimitiveValue::UnitType::String) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
             return createPrimitiveStringValue(value);
         }
 
         if (value->id == CSSValueNone) {
@@ skipping 10 matching lines @@
         } else if (value->id == CSSValueDot || value->id == CSSValueCircle || value->id == CSSValueDoubleCircle || value->id == CSSValueTriangle || value->id == CSSValueSesame) {
             if (shape)
                 return nullptr;
             shape = cssValuePool().createIdentifierValue(value->id);
         } else {
             break;
         }
     }
 
     if (fill && shape) {
-        RefPtrWillBeRawPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+        RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
         parsedValues->append(fill.release());
         parsedValues->append(shape.release());
         return parsedValues.release();
     }
     if (fill)
         return fill.release();
     if (shape)
         return shape.release();
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextIndent()
+PassRefPtr<CSSValue> CSSPropertyParser::parseTextIndent()
 {
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<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)) {
             list->append(createPrimitiveNumericValue(value));
             hasLengthOrPercentage = true;
@@ skipping 16 matching lines @@
         }
         return nullptr;
     }
 
     if (!hasLengthOrPercentage)
         return nullptr;
 
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSLineBoxContainValue> CSSPropertyParser::parseLineBoxContain()
+PassRefPtr<CSSLineBoxContainValue> CSSPropertyParser::parseLineBoxContain()
 {
     LineBoxContain lineBoxContain = LineBoxContainNone;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         LineBoxContainFlags flag;
         if (value->id == CSSValueBlock) {
             flag = LineBoxContainBlock;
         } else if (value->id == CSSValueInline) {
             flag = LineBoxContainInline;
         } else if (value->id == CSSValueFont) {
@@ skipping 46 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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseFontFeatureSettings()
 {
-    RefPtrWillBeRawPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
+    RefPtr<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;
     }
     return settings.release();
 }
 
 bool CSSPropertyParser::parseFontVariantLigatures(bool important)
 {
-    RefPtrWillBeRawPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
     bool sawCommonLigaturesValue = false;
     bool sawDiscretionaryLigaturesValue = false;
     bool sawHistoricalLigaturesValue = false;
     bool sawContextualLigaturesValue = false;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->m_unit != CSSParserValue::Identifier)
             return false;
 
         switch (value->id) {
@@ skipping 50 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;
+    RefPtr<CSSValue> parsedValue = nullptr;
 
     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 66 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;
+    RefPtr<CSSValue> parsedValue = nullptr;
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
 
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
             addProperty(propId, parsedValue.release(), important);
             return true;
         }
@@ skipping 104 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;
+    RefPtr<CSSValue> parsedValue = nullptr;
 
     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 CSSPropertyBaselineShift:
     // baseline | super | sub | <percentage> | <length> | inherit
         if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FLength | FPercent, SVGAttributeMode);
@@ skipping 44 matching lines @@
         }
         break;
 
     case CSSPropertyFill: // <paint> | inherit
     case CSSPropertyStroke: // <paint> | inherit
         {
             if (id == CSSValueNone) {
                 parsedValue = cssValuePool().createIdentifierValue(id);
             } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
                 if (m_valueList->next()) {
-                    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+                    RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
                     values->append(CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI));
                     if (m_valueList->current()->id == CSSValueNone)
                         parsedValue = cssValuePool().createIdentifierValue(m_valueList->current()->id);
                     else
                         parsedValue = parseColor(m_valueList->current());
                     if (parsedValue) {
                         values->append(parsedValue);
                         parsedValue = values;
                     }
                 }
@@ skipping 83 matching lines @@
         }
         m_valueList->next();
     }
     if (!parsedValue || (m_valueList->current() && !inShorthand()))
         return false;
 
     addProperty(propId, parsedValue.release(), important);
     return true;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSVGStrokeDasharray()
+PassRefPtr<CSSValue> CSSPropertyParser::parseSVGStrokeDasharray()
 {
-    RefPtrWillBeRawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
+    RefPtr<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::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
             ret->append(CSSPrimitiveValue::create(value->fValue, value->unit()));
         else if (value->unit() == CSSPrimitiveValue::UnitType::Rems || value->unit() == CSSPrimitiveValue::UnitType::Chs)
             ret->append(CSSPrimitiveValue::create(value->fValue, 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
+PassRefPtr<CSSValue> CSSPropertyParser::parsePaintOrder() const
 {
     if (m_valueList->size() > 3)
         return nullptr;
 
     CSSParserValue* value = m_valueList->current();
     ASSERT(value);
 
     Vector<CSSValueID, 3> paintTypeList;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> stroke = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> markers = nullptr;
+    RefPtr<CSSPrimitiveValue> fill = nullptr;
+    RefPtr<CSSPrimitiveValue> stroke = nullptr;
+    RefPtr<CSSPrimitiveValue> markers = nullptr;
     while (value) {
         if (value->id == CSSValueFill && !fill)
             fill = CSSPrimitiveValue::createIdentifier(value->id);
         else if (value->id == CSSValueStroke && !stroke)
             stroke = CSSPrimitiveValue::createIdentifier(value->id);
         else if (value->id == CSSValueMarkers && !markers)
             markers = CSSPrimitiveValue::createIdentifier(value->id);
         else
             return nullptr;
         paintTypeList.append(value->id);
         value = m_valueList->next();
     }
 
     // After parsing we serialize the paint-order list. Since it is not possible to
     // pop a last list items from CSSValueList without bigger cost, we create the
     // list after parsing.
     CSSValueID firstPaintOrderType = paintTypeList.at(0);
-    RefPtrWillBeRawPtr<CSSValueList> paintOrderList = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> paintOrderList = CSSValueList::createSpaceSeparated();
     switch (firstPaintOrderType) {
     case CSSValueFill:
     case CSSValueStroke:
         paintOrderList->append(firstPaintOrderType == CSSValueFill ? fill.release() : stroke.release());
         if (paintTypeList.size() > 1) {
             if (paintTypeList.at(1) == CSSValueMarkers)
                 paintOrderList->append(markers.release());
         }
         break;
     case CSSValueMarkers:
@@ skipping 105 matching lines @@
 
     bool hasCorrectArgCount(unsigned argCount) { return m_argCount == argCount || (m_allowSingleArgument && argCount == 1); }
 
 private:
     bool m_validID;
     bool m_allowSingleArgument;
     unsigned m_argCount;
     CSSPropertyParser::Units m_unit;
 };
 
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransform(bool useLegacyParsing)
+PassRefPtr<CSSValueList> CSSPropertyParser::parseTransform(bool useLegacyParsing)
 {
     if (!m_valueList)
         return nullptr;
 
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = parseTransformValue(useLegacyParsing, value);
+        RefPtr<CSSValue> parsedTransformValue = parseTransformValue(useLegacyParsing, value);
         if (!parsedTransformValue)
             return nullptr;
 
         list->append(parsedTransformValue.release());
     }
 
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTransformValue(bool useLegacyParsing, CSSParserValue *value)
+PassRefPtr<CSSValue> CSSPropertyParser::parseTransformValue(bool useLegacyParsing, CSSParserValue *value)
 {
     if (value->m_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.
     CSSValueID type = value->function->id;
     TransformOperationInfo info(type);
     if (!info.validID())
         return nullptr;
 
     if (!info.hasCorrectArgCount(args->size()))
         return nullptr;
 
     // The transform is a list of functional primitives that specify transform operations.
     // We collect a list of CSSFunctionValues, where each value specifies a single operation.
 
     // Create the new CSSFunctionValue for this operation and add it to our list.
-    RefPtrWillBeRawPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(type);
+    RefPtr<CSSFunctionValue> transformValue = CSSFunctionValue::create(type);
 
     // Snag our values.
     CSSParserValue* a = args->current();
     unsigned argNumber = 0;
     while (a) {
         CSSPropertyParser::Units unit = info.unit();
 
         if (type == CSSValueRotate3d && argNumber == 3) {
             // 4th param of rotate3d() is an angle rather than a bare number, validate it as such
             if (!validUnit(a, FAngle, HTMLStandardMode))
@@ skipping 28 matching lines @@
         if (!isComma(a))
             return nullptr;
         a = args->next();
 
         argNumber++;
     }
 
     return transformValue.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseMotionPath()
+PassRefPtr<CSSValue> CSSPropertyParser::parseMotionPath()
 {
     CSSParserValue* value = m_valueList->current();
 
     // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
     if (value->m_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::UnitType::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()
+PassRefPtr<CSSValue> CSSPropertyParser::parseMotionRotation()
 {
-    RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    RefPtr<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 (!hasAngle && validUnit(value, FAngle)) {
             list->append(createPrimitiveNumericValue(value));
             hasAngle = true;
         } else {
             break;
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink