Remove RawPtr from core/css

third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 47 matching lines @@
 #include "core/style/StyleVariableData.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 inline static bool isFlexOrGrid(const ComputedStyle* style)
 {
     return style && style->isDisplayFlexibleOrGridBox();
 }
 
-inline static RawPtr<CSSPrimitiveValue> zoomAdjustedPixelValue(double value, const ComputedStyle& style)
+inline static CSSPrimitiveValue* zoomAdjustedPixelValue(double value, const ComputedStyle& style)
 {
     return cssValuePool().createValue(adjustFloatForAbsoluteZoom(value, style), CSSPrimitiveValue::UnitType::Pixels);
 }
 
-inline static RawPtr<CSSPrimitiveValue> zoomAdjustedNumberValue(double value, const ComputedStyle& style)
+inline static CSSPrimitiveValue* zoomAdjustedNumberValue(double value, const ComputedStyle& style)
 {
     return cssValuePool().createValue(value / style.effectiveZoom(), CSSPrimitiveValue::UnitType::Number);
 }
 
-static RawPtr<CSSPrimitiveValue> zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
+static CSSPrimitiveValue* zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
 {
     if (length.isFixed())
         return zoomAdjustedPixelValue(length.value(), style);
     return cssValuePool().createValue(length, style);
 }
 
-static RawPtr<CSSPrimitiveValue> pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
+static CSSPrimitiveValue* pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
 {
     const Length& length = unzoomedLength.length();
     if (length.isFixed())
         return cssValuePool().createValue(length.value(), CSSPrimitiveValue::UnitType::Pixels);
     return cssValuePool().createValue(length, style);
 }
 
-static RawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
+static CSSValueList* createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> positionList = CSSValueList::createSpaceSeparated();
+    CSSValueList* positionList = CSSValueList::createSpaceSeparated();
     if (layer.isBackgroundXOriginSet()) {
         ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
         positionList->append(cssValuePool().createValue(layer.backgroundXOrigin()));
     }
     positionList->append(zoomAdjustedPixelValueForLength(layer.xPosition(), style));
     if (layer.isBackgroundYOriginSet()) {
         ASSERT(propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
         positionList->append(cssValuePool().createValue(layer.backgroundYOrigin()));
     }
     positionList->append(zoomAdjustedPixelValueForLength(layer.yPosition(), style));
-    return positionList.release();
+    return positionList;
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
+CSSValue* ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
 {
     // This function does NOT look at visited information, so that computed style doesn't expose that.
     return cssValuePool().createColorValue(color.resolve(style.color()).rgb());
 }
 
-static RawPtr<CSSValue> valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
+static CSSValue* valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
 {
     if (fillSize.type == Contain)
         return cssValuePool().createIdentifierValue(CSSValueContain);
 
     if (fillSize.type == Cover)
         return cssValuePool().createIdentifierValue(CSSValueCover);
 
     if (fillSize.size.height().isAuto())
         return zoomAdjustedPixelValueForLength(fillSize.size.width(), style);
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(zoomAdjustedPixelValueForLength(fillSize.size.width(), style));
     list->append(zoomAdjustedPixelValueForLength(fillSize.size.height(), style));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat)
+static CSSValue* valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat)
 {
     // For backwards compatibility, if both values are equal, just return one of them. And
     // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
     if (xRepeat == yRepeat)
         return cssValuePool().createValue(xRepeat);
     if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
         return cssValuePool().createIdentifierValue(CSSValueRepeatX);
     if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
         return cssValuePool().createIdentifierValue(CSSValueRepeatY);
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(cssValuePool().createValue(xRepeat));
     list->append(cssValuePool().createValue(yRepeat));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForFillSourceType(EMaskSourceType type)
+static CSSValue* valueForFillSourceType(EMaskSourceType type)
 {
     switch (type) {
     case MaskAlpha:
         return cssValuePool().createIdentifierValue(CSSValueAlpha);
     case MaskLuminance:
         return cssValuePool().createIdentifierValue(CSSValueLuminance);
     }
 
     ASSERT_NOT_REACHED();
 
     return nullptr;
 }
 
-static RawPtr<CSSValue> valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
+static CSSValue* valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
 {
     Length offset, opposite;
     switch (propertyID) {
     case CSSPropertyLeft:
         offset = style.left();
         opposite = style.right();
         break;
     case CSSPropertyRight:
         offset = style.right();
         opposite = style.left();
@@ skipping 69 matching lines @@
             return zoomAdjustedPixelValue(position, style);
         }
     }
 
     if (offset.isAuto())
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     return zoomAdjustedPixelValueForLength(offset, style);
 }
 
-static RawPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const NinePieceImage& image)
+static CSSBorderImageSliceValue* valueForNinePieceImageSlice(const NinePieceImage& image)
 {
     // Create the slices.
-    RawPtr<CSSPrimitiveValue> top = nullptr;
-    RawPtr<CSSPrimitiveValue> right = nullptr;
-    RawPtr<CSSPrimitiveValue> bottom = nullptr;
-    RawPtr<CSSPrimitiveValue> left = nullptr;
+    CSSPrimitiveValue* top = nullptr;
+    CSSPrimitiveValue* right = nullptr;
+    CSSPrimitiveValue* bottom = nullptr;
+    CSSPrimitiveValue* left = nullptr;
 
     // TODO(alancutter): Make this code aware of calc lengths.
     if (image.imageSlices().top().hasPercent())
         top = cssValuePool().createValue(image.imageSlices().top().value(), CSSPrimitiveValue::UnitType::Percentage);
     else
         top = cssValuePool().createValue(image.imageSlices().top().value(), CSSPrimitiveValue::UnitType::Number);
 
     if (image.imageSlices().right() == image.imageSlices().top() && image.imageSlices().bottom() == image.imageSlices().top()
         && image.imageSlices().left() == image.imageSlices().top()) {
         right = top;
@@ skipping 18 matching lines @@
                 left = right;
             } else {
                 if (image.imageSlices().left().hasPercent())
                     left = cssValuePool().createValue(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Percentage);
                 else
                     left = cssValuePool().createValue(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Number);
             }
         }
     }
 
-    return CSSBorderImageSliceValue::create(CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsQuad), image.fill());
+    return CSSBorderImageSliceValue::create(CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad), image.fill());
 }
 
-static RawPtr<CSSQuadValue> valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
+static CSSQuadValue* valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
 {
     // Create the slices.
-    RawPtr<CSSPrimitiveValue> top = nullptr;
-    RawPtr<CSSPrimitiveValue> right = nullptr;
-    RawPtr<CSSPrimitiveValue> bottom = nullptr;
-    RawPtr<CSSPrimitiveValue> left = nullptr;
+    CSSPrimitiveValue* top = nullptr;
+    CSSPrimitiveValue* right = nullptr;
+    CSSPrimitiveValue* bottom = nullptr;
+    CSSPrimitiveValue* left = nullptr;
 
     if (box.top().isNumber())
         top = cssValuePool().createValue(box.top().number(), CSSPrimitiveValue::UnitType::Number);
     else
         top = cssValuePool().createValue(box.top().length(), style);
 
     if (box.right() == box.top() && box.bottom() == box.top() && box.left() == box.top()) {
         right = top;
         bottom = top;
         left = top;
@@ skipping 16 matching lines @@
                 left = right;
             } else {
                 if (box.left().isNumber())
                     left = cssValuePool().createValue(box.left().number(), CSSPrimitiveValue::UnitType::Number);
                 else
                     left = cssValuePool().createValue(box.left().length(), style);
             }
         }
     }
 
-    return CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsQuad);
+    return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad);
 }
 
 static CSSValueID valueForRepeatRule(int rule)
 {
     switch (rule) {
     case RepeatImageRule:
         return CSSValueRepeat;
     case RoundImageRule:
         return CSSValueRound;
     case SpaceImageRule:
         return CSSValueSpace;
     default:
         return CSSValueStretch;
     }
 }
 
-static RawPtr<CSSValue> valueForNinePieceImageRepeat(const NinePieceImage& image)
+static CSSValue* valueForNinePieceImageRepeat(const NinePieceImage& image)
 {
-    RawPtr<CSSPrimitiveValue> horizontalRepeat = nullptr;
-    RawPtr<CSSPrimitiveValue> verticalRepeat = nullptr;
+    CSSPrimitiveValue* horizontalRepeat = nullptr;
+    CSSPrimitiveValue* verticalRepeat = nullptr;
 
     horizontalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.horizontalRule()));
     if (image.horizontalRule() == image.verticalRule())
         verticalRepeat = horizontalRepeat;
     else
         verticalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.verticalRule()));
-    return CSSValuePair::create(horizontalRepeat.release(), verticalRepeat.release(), CSSValuePair::DropIdenticalValues);
+    return CSSValuePair::create(horizontalRepeat, verticalRepeat, CSSValuePair::DropIdenticalValues);
 }
 
-static RawPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
+static CSSValue* valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
 {
     if (!image.hasImage())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     // Image first.
-    RawPtr<CSSValue> imageValue = nullptr;
+    CSSValue* imageValue = nullptr;
     if (image.image())
         imageValue = image.image()->computedCSSValue();
 
     // Create the image slice.
-    RawPtr<CSSBorderImageSliceValue> imageSlices = valueForNinePieceImageSlice(image);
+    CSSBorderImageSliceValue* imageSlices = valueForNinePieceImageSlice(image);
 
     // Create the border area slices.
-    RawPtr<CSSValue> borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);
+    CSSValue* borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);
 
     // Create the border outset.
-    RawPtr<CSSValue> outset = valueForNinePieceImageQuad(image.outset(), style);
+    CSSValue* outset = valueForNinePieceImageQuad(image.outset(), style);
 
     // Create the repeat rules.
-    RawPtr<CSSValue> repeat = valueForNinePieceImageRepeat(image);
+    CSSValue* repeat = valueForNinePieceImageRepeat(image);
 
-    return createBorderImageValue(imageValue.release(), imageSlices.release(), borderSlices.release(), outset.release(), repeat.release());
+    return createBorderImageValue(imageValue, imageSlices, borderSlices, outset, repeat);
 }
 
-static RawPtr<CSSValue> valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
+static CSSValue* valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
 {
     if (!reflection)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RawPtr<CSSPrimitiveValue> offset = nullptr;
+    CSSPrimitiveValue* offset = nullptr;
     // TODO(alancutter): Make this work correctly for calc lengths.
     if (reflection->offset().hasPercent())
         offset = cssValuePool().createValue(reflection->offset().percent(), CSSPrimitiveValue::UnitType::Percentage);
     else
         offset = zoomAdjustedPixelValue(reflection->offset().value(), style);
 
-    RawPtr<CSSPrimitiveValue> direction = nullptr;
+    CSSPrimitiveValue* direction = nullptr;
     switch (reflection->direction()) {
     case ReflectionBelow:
         direction = cssValuePool().createIdentifierValue(CSSValueBelow);
         break;
     case ReflectionAbove:
         direction = cssValuePool().createIdentifierValue(CSSValueAbove);
         break;
     case ReflectionLeft:
         direction = cssValuePool().createIdentifierValue(CSSValueLeft);
         break;
     case ReflectionRight:
         direction = cssValuePool().createIdentifierValue(CSSValueRight);
         break;
     }
 
-    return CSSReflectValue::create(direction.release(), offset.release(), valueForNinePieceImage(reflection->mask(), style));
+    return CSSReflectValue::create(direction, offset, valueForNinePieceImage(reflection->mask(), style));
 }
 
 static ItemPosition resolveAlignmentAuto(ItemPosition position, const ComputedStyle* style)
 {
     if (position != ItemPositionAuto)
         return position;
 
     if (!RuntimeEnabledFeatures::cssGridLayoutEnabled())
         return ItemPositionStretch;
 
     return isFlexOrGrid(style) ? ItemPositionStretch : ItemPositionStart;
 }
 
-static RawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
+static CSSValueList* valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
 {
-    RawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
+    CSSValueList* result = CSSValueList::createSpaceSeparated();
     if (positionType == LegacyPosition)
         result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
     result->append(CSSPrimitiveValue::create(itemPosition));
     if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
     ASSERT(result->length() <= 2);
-    return result.release();
+    return result;
 }
 
-static RawPtr<CSSValueList> valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
+static CSSValueList* valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
+    CSSValueList* list = CSSValueList::createSlashSeparated();
     for (size_t i = 0; i < shorthand.length(); ++i) {
-        RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
-        ASSERT(value);
-        list->append(value.release());
-    }
-    return list.release();
-}
-
-static RawPtr<CSSValueList> valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
-{
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-    for (size_t i = 0; i < shorthand.length(); ++i) {
-        RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
+        CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
         ASSERT(value);
         list->append(value);
     }
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValueList> valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
+static CSSValueList* valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
-    RawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
+    for (size_t i = 0; i < shorthand.length(); ++i) {
+        CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
+        ASSERT(value);
+        list->append(value);
+    }
+    return list;
+}
+
+static CSSValueList* valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
+{
+    CSSValueList* ret = CSSValueList::createCommaSeparated();
     const FillLayer* currLayer = &style.backgroundLayers();
     for (; currLayer; currLayer = currLayer->next()) {
-        RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
-        RawPtr<CSSValueList> beforeSlash = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSlashSeparated();
+        CSSValueList* beforeSlash = CSSValueList::createSpaceSeparated();
         if (!currLayer->next()) { // color only for final layer
-            RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
+            CSSValue* value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
             ASSERT(value);
             beforeSlash->append(value);
         }
         beforeSlash->append(currLayer->image() ? currLayer->image()->computedCSSValue() : cssValuePool().createIdentifierValue(CSSValueNone));
         beforeSlash->append(valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
         beforeSlash->append(cssValuePool().createValue(currLayer->attachment()));
         beforeSlash->append(createPositionListForLayer(CSSPropertyBackgroundPosition, *currLayer, style));
         list->append(beforeSlash);
-        RawPtr<CSSValueList> afterSlash = CSSValueList::createSpaceSeparated();
+        CSSValueList* afterSlash = CSSValueList::createSpaceSeparated();
         afterSlash->append(valueForFillSize(currLayer->size(), style));
         afterSlash->append(cssValuePool().createValue(currLayer->origin()));
         afterSlash->append(cssValuePool().createValue(currLayer->clip()));
         list->append(afterSlash);
         ret->append(list);
     }
-    return ret.release();
+    return ret;
 }
 
-static RawPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlignment(const StyleContentAlignmentData& data)
+static CSSValueList* valueForContentPositionAndDistributionWithOverflowAlignment(const StyleContentAlignmentData& data)
 {
-    RawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
+    CSSValueList* result = CSSValueList::createSpaceSeparated();
     if (data.distribution() != ContentDistributionDefault)
         result->append(CSSPrimitiveValue::create(data.distribution()));
     if (data.distribution() == ContentDistributionDefault || data.position() != ContentPositionNormal)
         result->append(CSSPrimitiveValue::create(data.position()));
     if ((data.position() >= ContentPositionCenter || data.distribution() != ContentDistributionDefault) && data.overflow() != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(data.overflow()));
     ASSERT(result->length() > 0);
     ASSERT(result->length() <= 3);
-    return result.release();
+    return result;
 }
 
-static RawPtr<CSSPrimitiveValue> valueForLineHeight(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForLineHeight(const ComputedStyle& style)
 {
     Length length = style.lineHeight();
     if (length.isNegative())
         return cssValuePool().createIdentifierValue(CSSValueNormal);
 
     return zoomAdjustedPixelValue(floatValueForLength(length, style.getFontDescription().computedSize()), style);
 }
 
 static CSSValueID identifierForFamily(const AtomicString& family)
 {
     if (family == FontFamilyNames::webkit_cursive)
         return CSSValueCursive;
     if (family == FontFamilyNames::webkit_fantasy)
         return CSSValueFantasy;
     if (family == FontFamilyNames::webkit_monospace)
         return CSSValueMonospace;
     if (family == FontFamilyNames::webkit_pictograph)
         return CSSValueWebkitPictograph;
     if (family == FontFamilyNames::webkit_sans_serif)
         return CSSValueSansSerif;
     if (family == FontFamilyNames::webkit_serif)
         return CSSValueSerif;
     return CSSValueInvalid;
 }
 
-static RawPtr<CSSValue> valueForFamily(const AtomicString& family)
+static CSSValue* valueForFamily(const AtomicString& family)
 {
     if (CSSValueID familyIdentifier = identifierForFamily(family))
         return cssValuePool().createIdentifierValue(familyIdentifier);
     return cssValuePool().createFontFamilyValue(family.getString());
 }
 
-static RawPtr<CSSValueList> valueForFontFamily(const ComputedStyle& style)
+static CSSValueList* valueForFontFamily(const ComputedStyle& style)
 {
     const FontFamily& firstFamily = style.getFontDescription().family();
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     for (const FontFamily* family = &firstFamily; family; family = family->next())
         list->append(valueForFamily(family->family()));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSPrimitiveValue> valueForFontSize(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForFontSize(const ComputedStyle& style)
 {
     return zoomAdjustedPixelValue(style.getFontDescription().computedSize(), style);
 }
 
-static RawPtr<CSSPrimitiveValue> valueForFontStretch(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForFontStretch(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.getFontDescription().stretch());
 }
 
-static RawPtr<CSSPrimitiveValue> valueForFontStyle(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForFontStyle(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.getFontDescription().style());
 }
 
-static RawPtr<CSSPrimitiveValue> valueForFontVariant(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForFontVariant(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.getFontDescription().variant());
 }
 
-static RawPtr<CSSPrimitiveValue> valueForFontWeight(const ComputedStyle& style)
+static CSSPrimitiveValue* valueForFontWeight(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.getFontDescription().weight());
 }
 
-static RawPtr<CSSValue> specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
+static CSSValue* specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
 {
     if (!trackBreadth.isLength())
         return cssValuePool().createValue(trackBreadth.flex(), CSSPrimitiveValue::UnitType::Fraction);
 
     const Length& trackBreadthLength = trackBreadth.length();
     if (trackBreadthLength.isAuto())
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     return zoomAdjustedPixelValueForLength(trackBreadthLength, style);
 }
 
-static RawPtr<CSSValue> specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const ComputedStyle& style)
+static CSSValue* specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const ComputedStyle& style)
 {
     switch (trackSize.type()) {
     case LengthTrackSizing:
         return specifiedValueForGridTrackBreadth(trackSize.length(), style);
     case MinMaxTrackSizing:
-        RawPtr<CSSFunctionValue> minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);
+        CSSFunctionValue* minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);
         minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style));
         minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.maxTrackBreadth(), style));
-        return minMaxTrackBreadths.release();
+        return minMaxTrackBreadths;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 static void addValuesForNamedGridLinesAtIndex(const OrderedNamedGridLines& orderedNamedGridLines, size_t i, CSSValueList& list)
 {
     const Vector<String>& namedGridLines = orderedNamedGridLines.get(i);
     if (namedGridLines.isEmpty())
         return;
 
-    RawPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
+    CSSGridLineNamesValue* lineNames = CSSGridLineNamesValue::create();
     for (size_t j = 0; j < namedGridLines.size(); ++j)
         lineNames->append(CSSCustomIdentValue::create(namedGridLines[j]));
-    list.append(lineNames.release());
+    list.append(lineNames);
 }
 
-static RawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
+static CSSValue* valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
 {
     bool isRowAxis = direction == ForColumns;
     const Vector<GridTrackSize>& trackSizes = isRowAxis ? style.gridTemplateColumns() : style.gridTemplateRows();
     const Vector<GridTrackSize>& autoRepeatTrackSizes = isRowAxis ? style.gridAutoRepeatColumns() : style.gridAutoRepeatRows();
     const OrderedNamedGridLines& orderedNamedGridLines = isRowAxis ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines();
 
     bool isLayoutGrid = layoutObject && layoutObject->isLayoutGrid();
 
     // Handle the 'none' case.
     bool trackListIsEmpty = trackSizes.isEmpty() && autoRepeatTrackSizes.isEmpty();
     if (isLayoutGrid && trackListIsEmpty) {
         // For grids we should consider every listed track, whether implicitly or explicitly created. If we don't have
         // any explicit track and there are no children then there are no implicit tracks. We cannot simply check the
         // number of rows/columns in our internal grid representation because it's always at least 1x1 (see r143331).
         trackListIsEmpty = !toLayoutBlock(layoutObject)->firstChild();
     }
 
     if (trackListIsEmpty) {
         ASSERT(orderedNamedGridLines.isEmpty());
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     size_t insertionIndex;
     if (isLayoutGrid) {
         const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toLayoutGrid(layoutObject)->columnPositions() : toLayoutGrid(layoutObject)->rowPositions();
         // There are at least #tracks + 1 grid lines (trackPositions). Apart from that, the grid container can generate implicit grid tracks,
         // so we'll have more trackPositions than trackSizes as the latter only contain the explicit grid.
         ASSERT(trackPositions.size() - 1 >= trackSizes.size());
 
         size_t i;
         LayoutUnit gutterSize = toLayoutGrid(layoutObject)->guttersSize(direction, 2);
         for (i = 0; i < trackPositions.size() - 2; ++i) {
             addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
             list->append(zoomAdjustedPixelValue(trackPositions[i + 1] - trackPositions[i] - gutterSize, style));
         }
         // Last track line does not have any gutter.
         addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
         list->append(zoomAdjustedPixelValue(trackPositions[i + 1] - trackPositions[i], style));
         insertionIndex = trackPositions.size() - 1;
     } else {
         for (size_t i = 0; i < trackSizes.size(); ++i) {
             addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
             list->append(specifiedValueForGridTrackSize(trackSizes[i], style));
         }
         insertionIndex = trackSizes.size();
     }
     // Those are the trailing <string>* allowed in the syntax.
     addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, insertionIndex, *list);
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForGridPosition(const GridPosition& position)
+static CSSValue* valueForGridPosition(const GridPosition& position)
 {
     if (position.isAuto())
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (position.isNamedGridArea())
         return CSSCustomIdentValue::create(position.namedGridLine());
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (position.isSpan()) {
         list->append(cssValuePool().createIdentifierValue(CSSValueSpan));
         list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::UnitType::Number));
     } else {
         list->append(cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::UnitType::Number));
     }
 
     if (!position.namedGridLine().isNull())
         list->append(CSSCustomIdentValue::create(position.namedGridLine()));
     return list;
 }
 
 static LayoutRect sizingBox(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
         return LayoutRect();
 
     const LayoutBox* box = toLayoutBox(layoutObject);
     return box->style()->boxSizing() == BoxSizingBorderBox ? box->borderBoxRect() : box->computedCSSContentBoxRect();
 }
 
-static RawPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration)
+static CSSValue* renderTextDecorationFlagsToCSSValue(int textDecoration)
 {
     // Blink value is ignored.
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (textDecoration & TextDecorationUnderline)
         list->append(cssValuePool().createIdentifierValue(CSSValueUnderline));
     if (textDecoration & TextDecorationOverline)
         list->append(cssValuePool().createIdentifierValue(CSSValueOverline));
     if (textDecoration & TextDecorationLineThrough)
         list->append(cssValuePool().createIdentifierValue(CSSValueLineThrough));
 
     if (!list->length())
         return cssValuePool().createIdentifierValue(CSSValueNone);
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForTextDecorationStyle(TextDecorationStyle textDecorationStyle)
+static CSSValue* valueForTextDecorationStyle(TextDecorationStyle textDecorationStyle)
 {
     switch (textDecorationStyle) {
     case TextDecorationStyleSolid:
         return cssValuePool().createIdentifierValue(CSSValueSolid);
     case TextDecorationStyleDouble:
         return cssValuePool().createIdentifierValue(CSSValueDouble);
     case TextDecorationStyleDotted:
         return cssValuePool().createIdentifierValue(CSSValueDotted);
     case TextDecorationStyleDashed:
         return cssValuePool().createIdentifierValue(CSSValueDashed);
     case TextDecorationStyleWavy:
         return cssValuePool().createIdentifierValue(CSSValueWavy);
     }
 
     ASSERT_NOT_REACHED();
     return cssValuePool().createExplicitInitialValue();
 }
 
-static RawPtr<CSSValue> touchActionFlagsToCSSValue(TouchAction touchAction)
+static CSSValue* touchActionFlagsToCSSValue(TouchAction touchAction)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (touchAction == TouchActionAuto) {
         list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
     } else if (touchAction == TouchActionNone) {
         list->append(cssValuePool().createIdentifierValue(CSSValueNone));
     } else if (touchAction == TouchActionManipulation) {
         list->append(cssValuePool().createIdentifierValue(CSSValueManipulation));
     } else {
         if ((touchAction & TouchActionPanX) == TouchActionPanX)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanX));
         else if (touchAction & TouchActionPanLeft)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanLeft));
         else if (touchAction & TouchActionPanRight)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanRight));
 
         if ((touchAction & TouchActionPanY) == TouchActionPanY)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanY));
         else if (touchAction & TouchActionPanUp)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanUp));
         else if (touchAction & TouchActionPanDown)
             list->append(cssValuePool().createIdentifierValue(CSSValuePanDown));
     }
     ASSERT(list->length());
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForWillChange(const Vector<CSSPropertyID>& willChangeProperties, bool willChangeContents, bool willChangeScrollPosition)
+static CSSValue* valueForWillChange(const Vector<CSSPropertyID>& willChangeProperties, bool willChangeContents, bool willChangeScrollPosition)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     if (willChangeContents)
         list->append(cssValuePool().createIdentifierValue(CSSValueContents));
     if (willChangeScrollPosition)
         list->append(cssValuePool().createIdentifierValue(CSSValueScrollPosition));
     for (size_t i = 0; i < willChangeProperties.size(); ++i)
         list->append(cssValuePool().createIdentifierValue(willChangeProperties[i]));
     if (!list->length())
         list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForAnimationDelay(const CSSTimingData* timingData)
+static CSSValue* valueForAnimationDelay(const CSSTimingData* timingData)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->delayList().size(); ++i)
             list->append(cssValuePool().createValue(timingData->delayList()[i], CSSPrimitiveValue::UnitType::Seconds));
     } else {
         list->append(cssValuePool().createValue(CSSTimingData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
     }
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForAnimationDirection(Timing::PlaybackDirection direction)
+static CSSValue* valueForAnimationDirection(Timing::PlaybackDirection direction)
 {
     switch (direction) {
     case Timing::PlaybackDirectionNormal:
         return cssValuePool().createIdentifierValue(CSSValueNormal);
     case Timing::PlaybackDirectionAlternate:
         return cssValuePool().createIdentifierValue(CSSValueAlternate);
     case Timing::PlaybackDirectionReverse:
         return cssValuePool().createIdentifierValue(CSSValueReverse);
     case Timing::PlaybackDirectionAlternateReverse:
         return cssValuePool().createIdentifierValue(CSSValueAlternateReverse);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
-static RawPtr<CSSValue> valueForAnimationDuration(const CSSTimingData* timingData)
+static CSSValue* valueForAnimationDuration(const CSSTimingData* timingData)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->durationList().size(); ++i)
             list->append(cssValuePool().createValue(timingData->durationList()[i], CSSPrimitiveValue::UnitType::Seconds));
     } else {
         list->append(cssValuePool().createValue(CSSTimingData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
     }
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForAnimationFillMode(Timing::FillMode fillMode)
+static CSSValue* valueForAnimationFillMode(Timing::FillMode fillMode)
 {
     switch (fillMode) {
     case Timing::FillModeNone:
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case Timing::FillModeForwards:
         return cssValuePool().createIdentifierValue(CSSValueForwards);
     case Timing::FillModeBackwards:
         return cssValuePool().createIdentifierValue(CSSValueBackwards);
     case Timing::FillModeBoth:
         return cssValuePool().createIdentifierValue(CSSValueBoth);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
-static RawPtr<CSSValue> valueForAnimationIterationCount(double iterationCount)
+static CSSValue* valueForAnimationIterationCount(double iterationCount)
 {
     if (iterationCount == std::numeric_limits<double>::infinity())
         return cssValuePool().createIdentifierValue(CSSValueInfinite);
     return cssValuePool().createValue(iterationCount, CSSPrimitiveValue::UnitType::Number);
 }
 
-static RawPtr<CSSValue> valueForAnimationPlayState(EAnimPlayState playState)
+static CSSValue* valueForAnimationPlayState(EAnimPlayState playState)
 {
     if (playState == AnimPlayStatePlaying)
         return cssValuePool().createIdentifierValue(CSSValueRunning);
     ASSERT(playState == AnimPlayStatePaused);
     return cssValuePool().createIdentifierValue(CSSValuePaused);
 }
 
-static RawPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFunction)
+static CSSValue* createTimingFunctionValue(const TimingFunction* timingFunction)
 {
     switch (timingFunction->type()) {
     case TimingFunction::kCubicBezierFunction:
         {
             const CubicBezierTimingFunction* bezierTimingFunction = toCubicBezierTimingFunction(timingFunction);
             if (bezierTimingFunction->subType() != CubicBezierTimingFunction::Custom) {
                 CSSValueID valueId = CSSValueInvalid;
                 switch (bezierTimingFunction->subType()) {
                 case CubicBezierTimingFunction::Ease:
                     valueId = CSSValueEase;
@@ skipping 27 matching lines @@
                 return CSSStepsTimingFunctionValue::create(steps, position);
             CSSValueID valueId = position == StepsTimingFunction::Start ? CSSValueStepStart : CSSValueStepEnd;
             return cssValuePool().createIdentifierValue(valueId);
         }
 
     default:
         return cssValuePool().createIdentifierValue(CSSValueLinear);
     }
 }
 
-static RawPtr<CSSValue> valueForAnimationTimingFunction(const CSSTimingData* timingData)
+static CSSValue* valueForAnimationTimingFunction(const CSSTimingData* timingData)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->timingFunctionList().size(); ++i)
             list->append(createTimingFunctionValue(timingData->timingFunctionList()[i].get()));
     } else {
         list->append(createTimingFunctionValue(CSSTimingData::initialTimingFunction().get()));
     }
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValueList> valuesForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
+static CSSValueList* valuesForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (radius.width().type() == Percent)
         list->append(cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::UnitType::Percentage));
     else
         list->append(zoomAdjustedPixelValueForLength(radius.width(), style));
     if (radius.height().type() == Percent)
         list->append(cssValuePool().createValue(radius.height().percent(), CSSPrimitiveValue::UnitType::Percentage));
     else
         list->append(zoomAdjustedPixelValueForLength(radius.height(), style));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
+static CSSValue* valueForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> list = valuesForBorderRadiusCorner(radius, style);
+    CSSValueList* list = valuesForBorderRadiusCorner(radius, style);
     if (list->item(0)->equals(*list->item(1)))
         return list->item(0);
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSFunctionValue> valueForMatrixTransform(const TransformationMatrix& transform, const ComputedStyle& style)
+static CSSFunctionValue* valueForMatrixTransform(const TransformationMatrix& transform, const ComputedStyle& style)
 {
-    RawPtr<CSSFunctionValue> transformValue = nullptr;
+    CSSFunctionValue* transformValue = nullptr;
     if (transform.isAffine()) {
         transformValue = CSSFunctionValue::create(CSSValueMatrix);
 
         transformValue->append(cssValuePool().createValue(transform.a(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(cssValuePool().createValue(transform.b(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(cssValuePool().createValue(transform.c(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(cssValuePool().createValue(transform.d(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(zoomAdjustedNumberValue(transform.e(), style));
         transformValue->append(zoomAdjustedNumberValue(transform.f(), style));
     } else {
@@ skipping 13 matching lines @@
         transformValue->append(cssValuePool().createValue(transform.m32(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(cssValuePool().createValue(transform.m33(), CSSPrimitiveValue::UnitType::Number));
         transformValue->append(cssValuePool().createValue(transform.m34(), CSSPrimitiveValue::UnitType::Number));
 
         transformValue->append(zoomAdjustedNumberValue(transform.m41(), style));
         transformValue->append(zoomAdjustedNumberValue(transform.m42(), style));
         transformValue->append(zoomAdjustedNumberValue(transform.m43(), style));
         transformValue->append(cssValuePool().createValue(transform.m44(), CSSPrimitiveValue::UnitType::Number));
     }
 
-    return transformValue.release();
+    return transformValue;
 }
 
-static RawPtr<CSSValue> computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
+static CSSValue* computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
 {
     if (!layoutObject || !style.hasTransform())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     IntRect box;
     if (layoutObject->isBox())
         box = pixelSnappedIntRect(toLayoutBox(layoutObject)->borderBoxRect());
 
     TransformationMatrix transform;
     style.applyTransform(transform, LayoutSize(box.size()), ComputedStyle::ExcludeTransformOrigin, ComputedStyle::ExcludeMotionPath, ComputedStyle::ExcludeIndependentTransformProperties);
 
     // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(valueForMatrixTransform(transform, style));
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
+static CSSValue* createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
 {
     if (property.propertyType == CSSTransitionData::TransitionNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (property.propertyType == CSSTransitionData::TransitionUnknownProperty)
         return CSSCustomIdentValue::create(property.propertyString);
     ASSERT(property.propertyType == CSSTransitionData::TransitionKnownProperty);
     return CSSCustomIdentValue::create(getPropertyNameString(property.unresolvedProperty));
 }
 
-static RawPtr<CSSValue> valueForTransitionProperty(const CSSTransitionData* transitionData)
+static CSSValue* valueForTransitionProperty(const CSSTransitionData* transitionData)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     if (transitionData) {
         for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
             list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
     } else {
         list->append(cssValuePool().createIdentifierValue(CSSValueAll));
     }
-    return list.release();
+    return list;
 }
 
 CSSValueID valueForQuoteType(const QuoteType quoteType)
 {
     switch (quoteType) {
     case NO_OPEN_QUOTE:
         return CSSValueNoOpenQuote;
     case NO_CLOSE_QUOTE:
         return CSSValueNoCloseQuote;
     case CLOSE_QUOTE:
         return CSSValueCloseQuote;
     case OPEN_QUOTE:
         return CSSValueOpenQuote;
     }
     ASSERT_NOT_REACHED();
     return CSSValueInvalid;
 }
 
-static RawPtr<CSSValue> valueForContentData(const ComputedStyle& style)
+static CSSValue* valueForContentData(const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (const ContentData* contentData = style.contentData(); contentData; contentData = contentData->next()) {
         if (contentData->isCounter()) {
             const CounterContent* counter = toCounterContentData(contentData)->counter();
             ASSERT(counter);
-            RawPtr<CSSCustomIdentValue> identifier = CSSCustomIdentValue::create(counter->identifier());
-            RawPtr<CSSCustomIdentValue> separator = CSSCustomIdentValue::create(counter->separator());
+            CSSCustomIdentValue* identifier = CSSCustomIdentValue::create(counter->identifier());
+            CSSCustomIdentValue* separator = CSSCustomIdentValue::create(counter->separator());
             CSSValueID listStyleIdent = CSSValueNone;
             if (counter->listStyle() != NoneListStyle)
                 listStyleIdent = static_cast<CSSValueID>(CSSValueDisc + counter->listStyle());
-            RawPtr<CSSPrimitiveValue> listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
-            list->append(CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release()));
+            CSSPrimitiveValue* listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
+            list->append(CSSCounterValue::create(identifier, listStyle, separator));
         } else if (contentData->isImage()) {
             const StyleImage* image = toImageContentData(contentData)->image();
             ASSERT(image);
             list->append(image->computedCSSValue());
         } else if (contentData->isText()) {
             list->append(CSSStringValue::create(toTextContentData(contentData)->text()));
         } else if (contentData->isQuote()) {
             const QuoteType quoteType = toQuoteContentData(contentData)->quote();
             list->append(cssValuePool().createIdentifierValue(valueForQuoteType(quoteType)));
         } else {
             ASSERT_NOT_REACHED();
         }
     }
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
+static CSSValue* valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
 {
     const CounterDirectiveMap* map = style.counterDirectives();
     if (!map)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (const auto& item : *map) {
         bool isValidCounterValue = propertyID == CSSPropertyCounterIncrement ? item.value.isIncrement() : item.value.isReset();
         if (!isValidCounterValue)
             continue;
 
         list->append(CSSCustomIdentValue::create(item.key));
         short number = propertyID == CSSPropertyCounterIncrement ? item.value.incrementValue() : item.value.resetValue();
         list->append(cssValuePool().createValue((double)number, CSSPrimitiveValue::UnitType::Integer));
     }
 
     if (!list->length())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForShape(const ComputedStyle& style, ShapeValue* shapeValue)
+static CSSValue* valueForShape(const ComputedStyle& style, ShapeValue* shapeValue)
 {
     if (!shapeValue)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (shapeValue->type() == ShapeValue::Box)
         return cssValuePool().createValue(shapeValue->cssBox());
     if (shapeValue->type() == ShapeValue::Image) {
         if (shapeValue->image())
             return shapeValue->image()->computedCSSValue();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     ASSERT(shapeValue->type() == ShapeValue::Shape);
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(valueForBasicShape(style, shapeValue->shape()));
     if (shapeValue->cssBox() != BoxMissing)
         list->append(cssValuePool().createValue(shapeValue->cssBox()));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValueList> valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
+static CSSValueList* valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     // Assume the properties are in the usual order top, right, bottom, left.
-    RawPtr<CSSValue> topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
-    RawPtr<CSSValue> rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
-    RawPtr<CSSValue> bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
-    RawPtr<CSSValue> leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, layoutObject, styledNode, allowVisitedStyle);
+    CSSValue* topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
+    CSSValue* rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
+    CSSValue* bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
+    CSSValue* leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, layoutObject, styledNode, allowVisitedStyle);
 
     // All 4 properties must be specified.
     if (!topValue || !rightValue || !bottomValue || !leftValue)
         return nullptr;
 
     bool showLeft = !compareCSSValuePtr(rightValue, leftValue);
     bool showBottom = !compareCSSValuePtr(topValue, bottomValue) || showLeft;
     bool showRight = !compareCSSValuePtr(topValue, rightValue) || showBottom;
 
-    list->append(topValue.release());
+    list->append(topValue);
     if (showRight)
-        list->append(rightValue.release());
+        list->append(rightValue);
     if (showBottom)
-        list->append(bottomValue.release());
+        list->append(bottomValue);
     if (showLeft)
-        list->append(leftValue.release());
+        list->append(leftValue);
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValueList> valueForBorderRadiusShorthand(const ComputedStyle& style)
+static CSSValueList* valueForBorderRadiusShorthand(const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
+    CSSValueList* list = CSSValueList::createSlashSeparated();
 
     bool showHorizontalBottomLeft = style.borderTopRightRadius().width() != style.borderBottomLeftRadius().width();
     bool showHorizontalBottomRight = showHorizontalBottomLeft || (style.borderBottomRightRadius().width() != style.borderTopLeftRadius().width());
     bool showHorizontalTopRight = showHorizontalBottomRight || (style.borderTopRightRadius().width() != style.borderTopLeftRadius().width());
 
     bool showVerticalBottomLeft = style.borderTopRightRadius().height() != style.borderBottomLeftRadius().height();
     bool showVerticalBottomRight = showVerticalBottomLeft || (style.borderBottomRightRadius().height() != style.borderTopLeftRadius().height());
     bool showVerticalTopRight = showVerticalBottomRight || (style.borderTopRightRadius().height() != style.borderTopLeftRadius().height());
 
-    RawPtr<CSSValueList> topLeftRadius = valuesForBorderRadiusCorner(style.borderTopLeftRadius(), style);
-    RawPtr<CSSValueList> topRightRadius = valuesForBorderRadiusCorner(style.borderTopRightRadius(), style);
-    RawPtr<CSSValueList> bottomRightRadius = valuesForBorderRadiusCorner(style.borderBottomRightRadius(), style);
-    RawPtr<CSSValueList> bottomLeftRadius = valuesForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
+    CSSValueList* topLeftRadius = valuesForBorderRadiusCorner(style.borderTopLeftRadius(), style);
+    CSSValueList* topRightRadius = valuesForBorderRadiusCorner(style.borderTopRightRadius(), style);
+    CSSValueList* bottomRightRadius = valuesForBorderRadiusCorner(style.borderBottomRightRadius(), style);
+    CSSValueList* bottomLeftRadius = valuesForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
 
-    RawPtr<CSSValueList> horizontalRadii = CSSValueList::createSpaceSeparated();
+    CSSValueList* horizontalRadii = CSSValueList::createSpaceSeparated();
     horizontalRadii->append(topLeftRadius->item(0));
     if (showHorizontalTopRight)
         horizontalRadii->append(topRightRadius->item(0));
     if (showHorizontalBottomRight)
         horizontalRadii->append(bottomRightRadius->item(0));
     if (showHorizontalBottomLeft)
         horizontalRadii->append(bottomLeftRadius->item(0));
 
-    list->append(horizontalRadii.release());
+    list->append(horizontalRadii);
 
-    RawPtr<CSSValueList> verticalRadii = CSSValueList::createSpaceSeparated();
+    CSSValueList* verticalRadii = CSSValueList::createSpaceSeparated();
     verticalRadii->append(topLeftRadius->item(1));
     if (showVerticalTopRight)
         verticalRadii->append(topRightRadius->item(1));
     if (showVerticalBottomRight)
         verticalRadii->append(bottomRightRadius->item(1));
     if (showVerticalBottomLeft)
         verticalRadii->append(bottomLeftRadius->item(1));
 
     if (!verticalRadii->equals(*toCSSValueList(list->item(0))))
-        list->append(verticalRadii.release());
+        list->append(verticalRadii);
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> strokeDashArrayToCSSValueList(const SVGDashArray& dashes, const ComputedStyle& style)
+static CSSValue* strokeDashArrayToCSSValueList(const SVGDashArray& dashes, const ComputedStyle& style)
 {
     if (dashes.isEmpty())
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     for (const Length& dashLength : dashes.vector())
         list->append(zoomAdjustedPixelValueForLength(dashLength, style));
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> paintOrderToCSSValueList(const SVGComputedStyle& svgStyle)
+static CSSValue* paintOrderToCSSValueList(const SVGComputedStyle& svgStyle)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (int i = 0; i < 3; i++) {
         EPaintOrderType paintOrderType = svgStyle.paintOrderType(i);
         switch (paintOrderType) {
         case PT_FILL:
         case PT_STROKE:
         case PT_MARKERS:
             list->append(CSSPrimitiveValue::create(paintOrderType));
             break;
         case PT_NONE:
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
+static CSSValue* adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
 {
     if (paintType >= SVG_PAINTTYPE_URI_NONE) {
-        RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
+        CSSValueList* values = CSSValueList::createSpaceSeparated();
         values->append(CSSURIValue::create(url));
         if (paintType == SVG_PAINTTYPE_URI_NONE)
             values->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
         else if (paintType == SVG_PAINTTYPE_URI_CURRENTCOLOR)
             values->append(CSSColorValue::create(currentColor.rgb()));
         else if (paintType == SVG_PAINTTYPE_URI_RGBCOLOR)
             values->append(CSSColorValue::create(color.rgb()));
-        return values.release();
+        return values;
     }
     if (paintType == SVG_PAINTTYPE_NONE)
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     if (paintType == SVG_PAINTTYPE_CURRENTCOLOR)
         return CSSColorValue::create(currentColor.rgb());
 
     return CSSColorValue::create(color.rgb());
 }
 
 static inline String serializeAsFragmentIdentifier(const AtomicString& resource)
 {
     return "#" + resource;
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
+CSSValue* ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
 {
-    RawPtr<CSSPrimitiveValue> x = zoomAdjustedPixelValue(shadow.x(), style);
-    RawPtr<CSSPrimitiveValue> y = zoomAdjustedPixelValue(shadow.y(), style);
-    RawPtr<CSSPrimitiveValue> blur = zoomAdjustedPixelValue(shadow.blur(), style);
-    RawPtr<CSSPrimitiveValue> spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : RawPtr<CSSPrimitiveValue>(nullptr);
-    RawPtr<CSSPrimitiveValue> shadowStyle = shadow.style() == Normal ? RawPtr<CSSPrimitiveValue>(nullptr) : cssValuePool().createIdentifierValue(CSSValueInset);
-    RawPtr<CSSValue> color = currentColorOrValidColor(style, shadow.color());
-    return CSSShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), shadowStyle.release(), color.release());
+    CSSPrimitiveValue* x = zoomAdjustedPixelValue(shadow.x(), style);
+    CSSPrimitiveValue* y = zoomAdjustedPixelValue(shadow.y(), style);
+    CSSPrimitiveValue* blur = zoomAdjustedPixelValue(shadow.blur(), style);
+    CSSPrimitiveValue* spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : nullptr;
+    CSSPrimitiveValue* shadowStyle = shadow.style() == Normal ? nullptr : cssValuePool().createIdentifierValue(CSSValueInset);
+    CSSValue* color = currentColorOrValidColor(style, shadow.color());
+    return CSSShadowValue::create(x, y, blur, spread, shadowStyle, color);
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
+CSSValue* ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
 {
     if (!shadowList)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
     size_t shadowCount = shadowList->shadows().size();
     for (size_t i = 0; i < shadowCount; ++i)
         list->append(valueForShadowData(shadowList->shadows()[i], style, useSpread));
-    return list.release();
+    return list;
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyle& style, const FilterOperations& filterOperations)
+CSSValue* ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyle& style, const FilterOperations& filterOperations)
 {
     if (filterOperations.operations().isEmpty())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
 
-    RawPtr<CSSFunctionValue> filterValue = nullptr;
+    CSSFunctionValue* filterValue = nullptr;
 
     for (const auto& operation : filterOperations.operations()) {
         FilterOperation* filterOperation = operation.get();
         switch (filterOperation->type()) {
         case FilterOperation::REFERENCE:
             filterValue = CSSFunctionValue::create(CSSValueUrl);
             filterValue->append(CSSStringValue::create(toReferenceFilterOperation(filterOperation)->url()));
             break;
         case FilterOperation::GRAYSCALE:
             filterValue = CSSFunctionValue::create(CSSValueGrayscale);
@@ skipping 36 matching lines @@
             filterValue = CSSFunctionValue::create(CSSValueDropShadow);
             // We want our computed style to look like that of a text shadow (has neither spread nor inset style).
             ShadowData shadow(dropShadowOperation->location(), dropShadowOperation->stdDeviation(), 0, Normal, StyleColor(dropShadowOperation->getColor()));
             filterValue->append(valueForShadowData(shadow, style, false));
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             break;
         }
-        list->append(filterValue.release());
+        list->append(filterValue);
     }
 
-    return list.release();
+    return list;
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForFont(const ComputedStyle& style)
+CSSValue* ComputedStyleCSSValueMapping::valueForFont(const ComputedStyle& style)
 {
     // Add a slash between size and line-height.
-    RawPtr<CSSValueList> sizeAndLineHeight = CSSValueList::createSlashSeparated();
+    CSSValueList* sizeAndLineHeight = CSSValueList::createSlashSeparated();
     sizeAndLineHeight->append(valueForFontSize(style));
     sizeAndLineHeight->append(valueForLineHeight(style));
 
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(valueForFontStyle(style));
     list->append(valueForFontVariant(style));
     list->append(valueForFontWeight(style));
     list->append(valueForFontStretch(style));
-    list->append(sizeAndLineHeight.release());
+    list->append(sizeAndLineHeight);
     list->append(valueForFontFamily(style));
 
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForScrollSnapDestination(const LengthPoint& destination, const ComputedStyle& style)
+static CSSValue* valueForScrollSnapDestination(const LengthPoint& destination, const ComputedStyle& style)
 {
-    RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+    CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(zoomAdjustedPixelValueForLength(destination.x(), style));
     list->append(zoomAdjustedPixelValueForLength(destination.y(), style));
-    return list.release();
+    return list;
 }
 
-static RawPtr<CSSValue> valueForScrollSnapPoints(const ScrollSnapPoints& points, const ComputedStyle& style)
+static CSSValue* valueForScrollSnapPoints(const ScrollSnapPoints& points, const ComputedStyle& style)
 {
     if (points.hasRepeat) {
-        RawPtr<CSSFunctionValue> repeat = CSSFunctionValue::create(CSSValueRepeat);
+        CSSFunctionValue* repeat = CSSFunctionValue::create(CSSValueRepeat);
         repeat->append(zoomAdjustedPixelValueForLength(points.repeatOffset, style));
-        return repeat.release();
+        return repeat;
     }
 
     return cssValuePool().createIdentifierValue(CSSValueNone);
 }
 
-static RawPtr<CSSValue> valueForScrollSnapCoordinate(const Vector<LengthPoint>& coordinates, const ComputedStyle& style)
+static CSSValue* valueForScrollSnapCoordinate(const Vector<LengthPoint>& coordinates, const ComputedStyle& style)
 {
     if (coordinates.isEmpty())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+    CSSValueList* list = CSSValueList::createCommaSeparated();
 
     for (auto& coordinate : coordinates) {
         auto pair = CSSValueList::createSpaceSeparated();
         pair->append(zoomAdjustedPixelValueForLength(coordinate.x(), style));
         pair->append(zoomAdjustedPixelValueForLength(coordinate.y(), style));
         list->append(pair);
     }
 
-    return list.release();
+    return list;
 }
 
 static EBreak mapToPageBreakValue(EBreak genericBreakValue)
 {
     switch (genericBreakValue) {
     case BreakAvoidColumn:
     case BreakColumn:
     case BreakRecto:
     case BreakVerso:
         return BreakAuto;
@@ skipping 18 matching lines @@
         return BreakAuto;
     case BreakColumn:
         return BreakAlways;
     case BreakAvoidColumn:
         return BreakAvoid;
     default:
         return genericBreakValue;
     }
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(const AtomicString customPropertyName, const ComputedStyle& style)
+CSSValue* ComputedStyleCSSValueMapping::get(const AtomicString customPropertyName, const ComputedStyle& style)
 {
     StyleVariableData* variables = style.variables();
     if (!variables)
         return nullptr;
 
     CSSVariableData* data = variables->getVariable(customPropertyName);
     if (!data)
         return nullptr;
 
     return CSSCustomPropertyDeclaration::create(customPropertyName, data);
 }
 
 const HashMap<AtomicString, RefPtr<CSSVariableData>>* ComputedStyleCSSValueMapping::getVariables(const ComputedStyle& style)
 {
     StyleVariableData* variables = style.variables();
     if (variables)
         return variables->getVariables();
     return nullptr;
 }
 
-RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
+CSSValue* ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     const SVGComputedStyle& svgStyle = style.svgStyle();
     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style.direction(), style.getWritingMode());
     switch (propertyID) {
     case CSSPropertyInvalid:
         return nullptr;
 
     case CSSPropertyBackgroundColor:
         return allowVisitedStyle ? cssValuePool().createColorValue(style.visitedDependentColor(CSSPropertyBackgroundColor).rgb()) : currentColorOrValidColor(style, style.backgroundColor());
     case CSSPropertyBackgroundImage:
     case CSSPropertyWebkitMaskImage: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskImage ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next()) {
             if (currLayer->image())
                 list->append(currLayer->image()->computedCSSValue());
             else
                 list->append(cssValuePool().createIdentifierValue(CSSValueNone));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundSize:
     case CSSPropertyWebkitMaskSize: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskSize ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(valueForFillSize(currLayer->size(), style));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundRepeat:
     case CSSPropertyWebkitMaskRepeat: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskRepeat ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
-        return list.release();
+        return list;
     }
     case CSSPropertyMaskSourceType: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.maskLayers(); currLayer; currLayer = currLayer->next())
             list->append(valueForFillSourceType(currLayer->maskSourceType()));
-        return list.release();
+        return list;
     }
     case CSSPropertyWebkitMaskComposite: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskComposite ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(cssValuePool().createValue(currLayer->composite()));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundAttachment: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
             list->append(cssValuePool().createValue(currLayer->attachment()));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundClip:
     case CSSPropertyBackgroundOrigin:
     case CSSPropertyWebkitBackgroundClip:
     case CSSPropertyWebkitBackgroundOrigin:
     case CSSPropertyWebkitMaskClip:
     case CSSPropertyWebkitMaskOrigin: {
         bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next()) {
             EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
             list->append(cssValuePool().createValue(box));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundPosition:
     case CSSPropertyWebkitMaskPosition: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPosition ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(createPositionListForLayer(propertyID, *currLayer, style));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundPositionX:
     case CSSPropertyWebkitMaskPositionX: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionX ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(zoomAdjustedPixelValueForLength(currLayer->xPosition(), style));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackgroundPositionY:
     case CSSPropertyWebkitMaskPositionY: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionY ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(zoomAdjustedPixelValueForLength(currLayer->yPosition(), style));
-        return list.release();
+        return list;
     }
     case CSSPropertyBorderCollapse:
         if (style.borderCollapse())
             return cssValuePool().createIdentifierValue(CSSValueCollapse);
         return cssValuePool().createIdentifierValue(CSSValueSeparate);
     case CSSPropertyBorderSpacing: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style));
         list->append(zoomAdjustedPixelValue(style.verticalBorderSpacing(), style));
-        return list.release();
+        return list;
     }
     case CSSPropertyWebkitBorderHorizontalSpacing:
         return zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style);
     case CSSPropertyWebkitBorderVerticalSpacing:
         return zoomAdjustedPixelValue(style.verticalBorderSpacing(), style);
     case CSSPropertyBorderImageSource:
         if (style.borderImageSource())
             return style.borderImageSource()->computedCSSValue();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyBorderTopColor:
@@ skipping 80 matching lines @@
     case CSSPropertyWebkitColumnBreakInside:
         return cssValuePool().createValue(mapToColumnBreakValue(style.breakInside()));
     case CSSPropertyColumnWidth:
         if (style.hasAutoColumnWidth())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return zoomAdjustedPixelValue(style.columnWidth(), style);
     case CSSPropertyTabSize:
         return cssValuePool().createValue(
             style.getTabSize().getPixelSize(1.0), style.getTabSize().isSpaces() ? CSSPrimitiveValue::UnitType::Number : CSSPrimitiveValue::UnitType::Pixels);
     case CSSPropertyCursor: {
-        RawPtr<CSSValueList> list = nullptr;
+        CSSValueList* list = nullptr;
         CursorList* cursors = style.cursors();
         if (cursors && cursors->size() > 0) {
             list = CSSValueList::createCommaSeparated();
             for (unsigned i = 0; i < cursors->size(); ++i) {
                 if (StyleImage* image = cursors->at(i).image())
                     list->append(image->computedCSSValue());
             }
         }
-        RawPtr<CSSValue> value = cssValuePool().createValue(style.cursor());
+        CSSValue* value = cssValuePool().createValue(style.cursor());
         if (list) {
-            list->append(value.release());
-            return list.release();
+            list->append(value);
+            return list;
         }
-        return value.release();
+        return value;
     }
     case CSSPropertyDirection:
         return cssValuePool().createValue(style.direction());
     case CSSPropertyDisplay:
         return cssValuePool().createValue(style.display());
     case CSSPropertyEmptyCells:
         return cssValuePool().createValue(style.emptyCells());
     case CSSPropertyAlignContent:
         return valueForContentPositionAndDistributionWithOverflowAlignment(style.alignContent());
     case CSSPropertyAlignItems:
@@ skipping 44 matching lines @@
     case CSSPropertyFontStyle:
         return valueForFontStyle(style);
     case CSSPropertyFontVariant:
         return valueForFontVariant(style);
     case CSSPropertyFontWeight:
         return valueForFontWeight(style);
     case CSSPropertyFontFeatureSettings: {
         const FontFeatureSettings* featureSettings = style.getFontDescription().featureSettings();
         if (!featureSettings || !featureSettings->size())
             return cssValuePool().createIdentifierValue(CSSValueNormal);
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         for (unsigned i = 0; i < featureSettings->size(); ++i) {
             const FontFeature& feature = featureSettings->at(i);
-            RawPtr<CSSFontFeatureValue> featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
-            list->append(featureValue.release());
+            CSSFontFeatureValue* featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
+            list->append(featureValue);
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyGridAutoFlow: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         switch (style.getGridAutoFlow()) {
         case AutoFlowRow:
         case AutoFlowRowDense:
             list->append(cssValuePool().createIdentifierValue(CSSValueRow));
             break;
         case AutoFlowColumn:
         case AutoFlowColumnDense:
             list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
             break;
         default:
             ASSERT_NOT_REACHED();
         }
 
         switch (style.getGridAutoFlow()) {
         case AutoFlowRowDense:
         case AutoFlowColumnDense:
             list->append(cssValuePool().createIdentifierValue(CSSValueDense));
             break;
         default:
             // Do nothing.
             break;
         }
 
-        return list.release();
+        return list;
     }
     // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
     // one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like
     // grid-auto-columns: 2fr; cannot be resolved to a value in pixels as the '2fr' means very different things
     // depending on the size of the explicit grid or the number of implicit tracks added to the grid. See
     // http://lists.w3.org/Archives/Public/www-style/2013Nov/0014.html
     case CSSPropertyGridAutoColumns:
         return specifiedValueForGridTrackSize(style.gridAutoColumns(), style);
     case CSSPropertyGridAutoRows:
         return specifiedValueForGridTrackSize(style.gridAutoRows(), style);
@@ skipping 221 matching lines @@
     case CSSPropertyPageBreakInside:
         return cssValuePool().createValue(mapToPageBreakValue(style.breakInside()));
     case CSSPropertyPosition:
         return cssValuePool().createValue(style.position());
     case CSSPropertyQuotes:
         if (!style.quotes()) {
             // TODO(ramya.v): We should return the quote values that we're actually using.
             return nullptr;
         }
         if (style.quotes()->size()) {
-            RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+            CSSValueList* list = CSSValueList::createSpaceSeparated();
             for (int i = 0; i < style.quotes()->size(); i++) {
                 list->append(CSSStringValue::create(style.quotes()->getOpenQuote(i)));
                 list->append(CSSStringValue::create(style.quotes()->getCloseQuote(i)));
             }
-            return list.release();
+            return list;
         }
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyRight:
         return valueForPositionOffset(style, CSSPropertyRight, layoutObject);
     case CSSPropertyWebkitRubyPosition:
         return cssValuePool().createValue(style.getRubyPosition());
     case CSSPropertyScrollBehavior:
         return cssValuePool().createValue(style.getScrollBehavior());
     case CSSPropertyTableLayout:
         return cssValuePool().createValue(style.tableLayout());
@@ skipping 30 matching lines @@
         case TextEmphasisMarkCustom:
             return CSSStringValue::create(style.textEmphasisCustomMark());
         case TextEmphasisMarkAuto:
             ASSERT_NOT_REACHED();
             // Fall through
         case TextEmphasisMarkDot:
         case TextEmphasisMarkCircle:
         case TextEmphasisMarkDoubleCircle:
         case TextEmphasisMarkTriangle:
         case TextEmphasisMarkSesame: {
-            RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+            CSSValueList* list = CSSValueList::createSpaceSeparated();
             list->append(cssValuePool().createValue(style.getTextEmphasisFill()));
             list->append(cssValuePool().createValue(style.getTextEmphasisMark()));
-            return list.release();
+            return list;
         }
         }
     case CSSPropertyTextIndent: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(zoomAdjustedPixelValueForLength(style.textIndent(), style));
         if (RuntimeEnabledFeatures::css3TextEnabled() && (style.getTextIndentLine() == TextIndentEachLine || style.getTextIndentType() == TextIndentHanging)) {
             if (style.getTextIndentLine() == TextIndentEachLine)
                 list->append(cssValuePool().createIdentifierValue(CSSValueEachLine));
             if (style.getTextIndentType() == TextIndentHanging)
                 list->append(cssValuePool().createIdentifierValue(CSSValueHanging));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyTextShadow:
         return valueForShadowList(style.textShadow(), style, false);
     case CSSPropertyTextRendering:
         return cssValuePool().createValue(style.getFontDescription().textRendering());
     case CSSPropertyTextOverflow:
         if (style.getTextOverflow())
             return cssValuePool().createIdentifierValue(CSSValueEllipsis);
         return cssValuePool().createIdentifierValue(CSSValueClip);
     case CSSPropertyWebkitTextSecurity:
@@ skipping 68 matching lines @@
         return cssValuePool().createValue(style.getFontDescription().fontSmoothing());
     case CSSPropertyFontVariantLigatures: {
         FontDescription::LigaturesState commonLigaturesState = style.getFontDescription().commonLigaturesState();
         FontDescription::LigaturesState discretionaryLigaturesState = style.getFontDescription().discretionaryLigaturesState();
         FontDescription::LigaturesState historicalLigaturesState = style.getFontDescription().historicalLigaturesState();
         FontDescription::LigaturesState contextualLigaturesState = style.getFontDescription().contextualLigaturesState();
         if (commonLigaturesState == FontDescription::NormalLigaturesState && discretionaryLigaturesState == FontDescription::NormalLigaturesState
             && historicalLigaturesState == FontDescription::NormalLigaturesState && contextualLigaturesState == FontDescription::NormalLigaturesState)
             return cssValuePool().createIdentifierValue(CSSValueNormal);
 
-        RawPtr<CSSValueList> valueList = CSSValueList::createSpaceSeparated();
+        CSSValueList* valueList = CSSValueList::createSpaceSeparated();
         if (commonLigaturesState != FontDescription::NormalLigaturesState)
             valueList->append(cssValuePool().createIdentifierValue(commonLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoCommonLigatures : CSSValueCommonLigatures));
         if (discretionaryLigaturesState != FontDescription::NormalLigaturesState)
             valueList->append(cssValuePool().createIdentifierValue(discretionaryLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoDiscretionaryLigatures : CSSValueDiscretionaryLigatures));
         if (historicalLigaturesState != FontDescription::NormalLigaturesState)
             valueList->append(cssValuePool().createIdentifierValue(historicalLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoHistoricalLigatures : CSSValueHistoricalLigatures));
         if (contextualLigaturesState != FontDescription::NormalLigaturesState)
             valueList->append(cssValuePool().createIdentifierValue(contextualLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoContextual : CSSValueContextual));
         return valueList;
     }
     case CSSPropertyZIndex:
         if (style.hasAutoZIndex())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return cssValuePool().createValue(style.zIndex(), CSSPrimitiveValue::UnitType::Integer);
     case CSSPropertyZoom:
         return cssValuePool().createValue(style.zoom(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyBoxSizing:
         if (style.boxSizing() == BoxSizingContentBox)
             return cssValuePool().createIdentifierValue(CSSValueContentBox);
         return cssValuePool().createIdentifierValue(CSSValueBorderBox);
     case CSSPropertyWebkitAppRegion:
         return cssValuePool().createIdentifierValue(style.getDraggableRegionMode() == DraggableRegionDrag ? CSSValueDrag : CSSValueNoDrag);
     case CSSPropertyAnimationDelay:
         return valueForAnimationDelay(style.animations());
     case CSSPropertyAnimationDirection: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->directionList().size(); ++i)
                 list->append(valueForAnimationDirection(animationData->directionList()[i]));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyAnimationDuration:
         return valueForAnimationDuration(style.animations());
     case CSSPropertyAnimationFillMode: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->fillModeList().size(); ++i)
                 list->append(valueForAnimationFillMode(animationData->fillModeList()[i]));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueNone));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyAnimationIterationCount: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->iterationCountList().size(); ++i)
                 list->append(valueForAnimationIterationCount(animationData->iterationCountList()[i]));
         } else {
             list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyAnimationName: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->nameList().size(); ++i)
                 list->append(CSSCustomIdentValue::create(animationData->nameList()[i]));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueNone));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyAnimationPlayState: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->playStateList().size(); ++i)
                 list->append(valueForAnimationPlayState(animationData->playStateList()[i]));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyAnimationTimingFunction:
         return valueForAnimationTimingFunction(style.animations());
     case CSSPropertyAnimation: {
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
-            RawPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
+            CSSValueList* animationsList = CSSValueList::createCommaSeparated();
             for (size_t i = 0; i < animationData->nameList().size(); ++i) {
-                RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+                CSSValueList* list = CSSValueList::createSpaceSeparated();
                 list->append(CSSCustomIdentValue::create(animationData->nameList()[i]));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(valueForAnimationIterationCount(CSSTimingData::getRepeated(animationData->iterationCountList(), i)));
                 list->append(valueForAnimationDirection(CSSTimingData::getRepeated(animationData->directionList(), i)));
                 list->append(valueForAnimationFillMode(CSSTimingData::getRepeated(animationData->fillModeList(), i)));
                 list->append(valueForAnimationPlayState(CSSTimingData::getRepeated(animationData->playStateList(), i)));
                 animationsList->append(list);
             }
-            return animationsList.release();
+            return animationsList;
         }
 
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         // animation-name default value.
         list->append(cssValuePool().createIdentifierValue(CSSValueNone));
         list->append(cssValuePool().createValue(CSSAnimationData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(createTimingFunctionValue(CSSAnimationData::initialTimingFunction().get()));
         list->append(cssValuePool().createValue(CSSAnimationData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
         list->append(valueForAnimationDirection(CSSAnimationData::initialDirection()));
         list->append(valueForAnimationFillMode(CSSAnimationData::initialFillMode()));
         // Initial animation-play-state.
         list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
-        return list.release();
+        return list;
     }
     case CSSPropertyWebkitAppearance:
         return cssValuePool().createValue(style.appearance());
     case CSSPropertyBackfaceVisibility:
         return cssValuePool().createIdentifierValue((style.backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
     case CSSPropertyWebkitBorderImage:
         return valueForNinePieceImage(style.borderImage(), style);
     case CSSPropertyBorderImageOutset:
         return valueForNinePieceImageQuad(style.borderImage().outset(), style);
     case CSSPropertyBorderImageRepeat:
@@ skipping 23 matching lines @@
     case CSSPropertyWebkitMarginAfterCollapse:
         return cssValuePool().createValue(style.marginAfterCollapse());
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyWebkitMarginBeforeCollapse:
         return cssValuePool().createValue(style.marginBeforeCollapse());
     case CSSPropertyPerspective:
         if (!style.hasPerspective())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return zoomAdjustedPixelValue(style.perspective(), style);
     case CSSPropertyPerspectiveOrigin: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (layoutObject) {
             LayoutRect box;
             if (layoutObject->isBox())
                 box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginY(), box.height()), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyWebkitRtlOrdering:
         return cssValuePool().createIdentifierValue(style.rtlOrdering() ? CSSValueVisual : CSSValueLogical);
     case CSSPropertyWebkitTapHighlightColor:
         return currentColorOrValidColor(style, style.tapHighlightColor());
     case CSSPropertyWebkitUserDrag:
         return cssValuePool().createValue(style.userDrag());
     case CSSPropertyWebkitUserSelect:
         return cssValuePool().createValue(style.userSelect());
     case CSSPropertyBorderBottomLeftRadius:
         return valueForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
     case CSSPropertyBorderBottomRightRadius:
         return valueForBorderRadiusCorner(style.borderBottomRightRadius(), style);
     case CSSPropertyBorderTopLeftRadius:
         return valueForBorderRadiusCorner(style.borderTopLeftRadius(), style);
     case CSSPropertyBorderTopRightRadius:
         return valueForBorderRadiusCorner(style.borderTopRightRadius(), style);
     case CSSPropertyClip: {
         if (style.hasAutoClip())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
-        RawPtr<CSSPrimitiveValue> top = style.clip().top().isAuto()
+        CSSPrimitiveValue* top = style.clip().top().isAuto()
             ? cssValuePool().createIdentifierValue(CSSValueAuto)
             : zoomAdjustedPixelValue(style.clip().top().value(), style);
-        RawPtr<CSSPrimitiveValue> right = style.clip().right().isAuto()
+        CSSPrimitiveValue* right = style.clip().right().isAuto()
             ? cssValuePool().createIdentifierValue(CSSValueAuto)
             : zoomAdjustedPixelValue(style.clip().right().value(), style);
-        RawPtr<CSSPrimitiveValue> bottom = style.clip().bottom().isAuto()
+        CSSPrimitiveValue* bottom = style.clip().bottom().isAuto()
             ? cssValuePool().createIdentifierValue(CSSValueAuto)
             : zoomAdjustedPixelValue(style.clip().bottom().value(), style);
-        RawPtr<CSSPrimitiveValue> left = style.clip().left().isAuto()
+        CSSPrimitiveValue* left = style.clip().left().isAuto()
             ? cssValuePool().createIdentifierValue(CSSValueAuto)
             : zoomAdjustedPixelValue(style.clip().left().value(), style);
-        return CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsRect);
+        return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsRect);
     }
     case CSSPropertySpeak:
         return cssValuePool().createValue(style.speak());
     case CSSPropertyTransform:
         return computedTransform(layoutObject, style);
     case CSSPropertyTransformOrigin: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (layoutObject) {
             LayoutRect box;
             if (layoutObject->isBox())
                 box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginY(), box.height()), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginY(), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyTransformStyle:
         return cssValuePool().createIdentifierValue((style.transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
     case CSSPropertyTransitionDelay:
         return valueForAnimationDelay(style.transitions());
     case CSSPropertyTransitionDuration:
         return valueForAnimationDuration(style.transitions());
     case CSSPropertyTransitionProperty:
         return valueForTransitionProperty(style.transitions());
     case CSSPropertyTransitionTimingFunction:
         return valueForAnimationTimingFunction(style.transitions());
     case CSSPropertyTransition: {
         const CSSTransitionData* transitionData = style.transitions();
         if (transitionData) {
-            RawPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();
+            CSSValueList* transitionsList = CSSValueList::createCommaSeparated();
             for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
-                RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+                CSSValueList* list = CSSValueList::createSpaceSeparated();
                 list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(createTimingFunctionValue(CSSTimingData::getRepeated(transitionData->timingFunctionList(), i).get()));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 transitionsList->append(list);
             }
-            return transitionsList.release();
+            return transitionsList;
         }
 
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         // transition-property default value.
         list->append(cssValuePool().createIdentifierValue(CSSValueAll));
         list->append(cssValuePool().createValue(CSSTransitionData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(createTimingFunctionValue(CSSTransitionData::initialTimingFunction().get()));
         list->append(cssValuePool().createValue(CSSTransitionData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
-        return list.release();
+        return list;
     }
     case CSSPropertyPointerEvents:
         return cssValuePool().createValue(style.pointerEvents());
     case CSSPropertyWritingMode:
     case CSSPropertyWebkitWritingMode:
         return cssValuePool().createValue(style.getWritingMode());
     case CSSPropertyWebkitTextCombine:
         if (style.getTextCombine() == TextCombineAll)
             return CSSPrimitiveValue::createIdentifier(CSSValueHorizontal);
     case CSSPropertyTextCombineUpright:
@@ skipping 28 matching lines @@
     case CSSPropertyShapeOutside:
         return valueForShape(style, style.shapeOutside());
     case CSSPropertyWebkitFilter:
         return valueForFilter(style, style.filter());
     case CSSPropertyBackdropFilter:
         return valueForFilter(style, style.backdropFilter());
     case CSSPropertyMixBlendMode:
         return cssValuePool().createValue(style.blendMode());
 
     case CSSPropertyBackgroundBlendMode: {
-        RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+        CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
             list->append(cssValuePool().createValue(currLayer->blendMode()));
-        return list.release();
+        return list;
     }
     case CSSPropertyBackground:
         return valuesForBackgroundShorthand(style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorder: {
-        RawPtr<CSSValue> value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
+        CSSValue* value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
         const CSSPropertyID properties[] = {
             CSSPropertyBorderRight,
             CSSPropertyBorderBottom,
             CSSPropertyBorderLeft
         };
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(properties); ++i) {
             if (!compareCSSValuePtr<CSSValue>(value, get(properties[i], style, layoutObject, styledNode, allowVisitedStyle)))
                 return nullptr;
         }
-        return value.release();
+        return value;
     }
     case CSSPropertyBorderBottom:
         return valuesForShorthandProperty(borderBottomShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderColor:
         return valuesForSidesShorthand(borderColorShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderLeft:
         return valuesForShorthandProperty(borderLeftShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderImage:
         return valueForNinePieceImage(style.borderImage(), style);
     case CSSPropertyBorderRadius:
@@ skipping 28 matching lines @@
 
     case CSSPropertyMotionPath:
         if (const StylePath* styleMotionPath = style.motionPath())
             return styleMotionPath->computedCSSValue();
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     case CSSPropertyMotionOffset:
         return zoomAdjustedPixelValueForLength(style.motionOffset(), style);
 
     case CSSPropertyMotionRotation: {
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (style.motionRotation().type == MotionRotationAuto)
             list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
         list->append(cssValuePool().createValue(style.motionRotation().angle, CSSPrimitiveValue::UnitType::Degrees));
-        return list.release();
+        return list;
     }
 
     // Unimplemented CSS 3 properties (including CSS3 shorthand properties).
     case CSSPropertyWebkitTextEmphasis:
         return nullptr;
 
     // Directional properties are resolved by resolveDirectionAwareProperty() before the switch.
     case CSSPropertyWebkitBorderEnd:
     case CSSPropertyWebkitBorderEndColor:
     case CSSPropertyWebkitBorderEndStyle:
@@ skipping 178 matching lines @@
     case CSSPropertyScrollSnapPointsY:
         return valueForScrollSnapPoints(style.scrollSnapPointsY(), style);
     case CSSPropertyScrollSnapCoordinate:
         return valueForScrollSnapCoordinate(style.scrollSnapCoordinate(), style);
     case CSSPropertyScrollSnapDestination:
         return valueForScrollSnapDestination(style.scrollSnapDestination(), style);
     case CSSPropertyTranslate: {
         if (!style.translate())
             return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
 
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (layoutObject && layoutObject->isBox()) {
             LayoutRect box = toLayoutBox(layoutObject)->borderBoxRect();
             list->append(zoomAdjustedPixelValue(floatValueForLength(style.translate()->x(), box.width().toFloat()), style));
 
             if (!style.translate()->y().isZero() || style.translate()->z() != 0)
                 list->append(zoomAdjustedPixelValue(floatValueForLength(style.translate()->y(), box.height().toFloat()), style));
 
         } else {
             // No box to resolve the percentage values
             list->append(zoomAdjustedPixelValueForLength(style.translate()->x(), style));
 
             if (!style.translate()->y().isZero() || style.translate()->z() != 0)
                 list->append(zoomAdjustedPixelValueForLength(style.translate()->y(), style));
         }
 
         if (style.translate()->z() != 0)
             list->append(zoomAdjustedPixelValue(style.translate()->z(), style));
 
-        return list.release();
+        return list;
     }
     case CSSPropertyRotate: {
         if (!style.rotate())
             return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Degrees);
 
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(cssValuePool().createValue(style.rotate()->angle(), CSSPrimitiveValue::UnitType::Degrees));
         if (style.rotate()->x() != 0 || style.rotate()->y() != 0 || style.rotate()->z() != 1) {
             list->append(cssValuePool().createValue(style.rotate()->x(), CSSPrimitiveValue::UnitType::Number));
             list->append(cssValuePool().createValue(style.rotate()->y(), CSSPrimitiveValue::UnitType::Number));
             list->append(cssValuePool().createValue(style.rotate()->z(), CSSPrimitiveValue::UnitType::Number));
         }
-        return list.release();
+        return list;
     }
     case CSSPropertyScale: {
         if (!style.scale())
             return cssValuePool().createValue(1, CSSPrimitiveValue::UnitType::Number);
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(cssValuePool().createValue(style.scale()->x(), CSSPrimitiveValue::UnitType::Number));
         if (style.scale()->y() == 1 && style.scale()->z() == 1)
-            return list.release();
+            return list;
         list->append(cssValuePool().createValue(style.scale()->y(), CSSPrimitiveValue::UnitType::Number));
         if (style.scale()->z() != 1)
             list->append(cssValuePool().createValue(style.scale()->z(), CSSPrimitiveValue::UnitType::Number));
-        return list.release();
+        return list;
     }
     case CSSPropertyContain: {
         if (!style.contain())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         if (style.contain() == ContainsStrict)
             return cssValuePool().createIdentifierValue(CSSValueStrict);
 
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (style.containsStyle())
             list->append(cssValuePool().createIdentifierValue(CSSValueStyle));
         if (style.contain() & ContainsLayout)
             list->append(cssValuePool().createIdentifierValue(CSSValueLayout));
         if (style.containsPaint())
             list->append(cssValuePool().createIdentifierValue(CSSValuePaint));
         ASSERT(list->length());
-        return list.release();
+        return list;
     }
     case CSSPropertySnapHeight: {
         if (!style.snapHeightUnit())
             return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
-        RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+        CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(cssValuePool().createValue(style.snapHeightUnit(), CSSPrimitiveValue::UnitType::Pixels));
         if (style.snapHeightPosition())
             list->append(cssValuePool().createValue(style.snapHeightPosition(), CSSPrimitiveValue::UnitType::Integer));
-        return list.release();
+        return list;
     }
     case CSSPropertyVariable:
         // Variables are retrieved via get(AtomicString).
         ASSERT_NOT_REACHED();
         return nullptr;
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink