CSSValue Immediates: Make CSSPrimitiveValue a container

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 44 matching lines @@
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 inline static bool isFlexOrGrid(Node* element)
 {
     return element && element->ensureComputedStyle()
         && element->ensureComputedStyle()->isDisplayFlexibleOrGridBox();
 }
 
-inline static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> zoomAdjustedPixelValue(double value, const ComputedStyle& style)
+inline static CSSPrimitiveValue zoomAdjustedPixelValue(double value, const ComputedStyle& style)
 {
     return cssValuePool().createValue(adjustFloatForAbsoluteZoom(value, style), CSSPrimitiveValue::CSS_PX);
 }
 
-inline static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> zoomAdjustedNumberValue(double value, const ComputedStyle& style)
+inline static CSSPrimitiveValue zoomAdjustedNumberValue(double value, const ComputedStyle& style)
 {
     return cssValuePool().createValue(value / style.effectiveZoom(), CSSPrimitiveValue::CSS_NUMBER);
 }
 
-static PassRefPtrWillBeRawPtr<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 PassRefPtrWillBeRawPtr<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::CSS_PX);
     return cssValuePool().createValue(length, style);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
 {
     RefPtrWillBeRawPtr<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();
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
+CSSPrimitiveValue 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 CSSValue valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
 {
     if (fillSize.type == Contain)
         return cssValuePool().createIdentifierValue(CSSValueContain);
 
@@ skipping 71 matching lines @@
         // So we should get the opposite length unit and see if it is auto.
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     return zoomAdjustedPixelValueForLength(offset, style);
 }
 
 static PassRefPtrWillBeRawPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const NinePieceImage& image)
 {
     // Create the slices.
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> top = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> right = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> bottom = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> left = nullptr;
+    NullableCSSValue top;
+    NullableCSSValue right;
+    NullableCSSValue bottom;
+    NullableCSSValue left;
 
     // TODO(alancutter): Make this code aware of calc lengths.
     if (image.imageSlices().top().hasPercent())
         top = cssValuePool().createValue(image.imageSlices().top().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
     else
         top = cssValuePool().createValue(image.imageSlices().top().value(), CSSPrimitiveValue::CSS_NUMBER);
 
     if (image.imageSlices().right() == image.imageSlices().top() && image.imageSlices().bottom() == image.imageSlices().top()
         && image.imageSlices().left() == image.imageSlices().top()) {
         right = top;
@@ skipping 19 matching lines @@
             } else {
                 if (image.imageSlices().left().hasPercent())
                     left = cssValuePool().createValue(image.imageSlices().left().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
                 else
                     left = cssValuePool().createValue(image.imageSlices().left().value(), CSSPrimitiveValue::CSS_NUMBER);
             }
         }
     }
 
     RefPtrWillBeRawPtr<Quad> quad = Quad::create();
-    quad->setTop(top);
-    quad->setRight(right);
-    quad->setBottom(bottom);
-    quad->setLeft(left);
+    quad->setTop(toCSSPrimitiveValue(*top));
+    quad->setRight(toCSSPrimitiveValue(*right));
+    quad->setBottom(toCSSPrimitiveValue(*bottom));
+    quad->setLeft(toCSSPrimitiveValue(*left));
 
     return CSSBorderImageSliceValue::create(cssValuePool().createValue(quad.release()), image.fill());
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
+static CSSPrimitiveValue valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
 {
     // Create the slices.
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> top = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> right = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> bottom = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> left = nullptr;
+    NullableCSSValue top;
+    NullableCSSValue right;
+    NullableCSSValue bottom;
+    NullableCSSValue left;
 
     if (box.top().isNumber())
         top = cssValuePool().createValue(box.top().number(), CSSPrimitiveValue::CSS_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 17 matching lines @@
             } else {
                 if (box.left().isNumber())
                     left = cssValuePool().createValue(box.left().number(), CSSPrimitiveValue::CSS_NUMBER);
                 else
                     left = cssValuePool().createValue(box.left().length(), style);
             }
         }
     }
 
     RefPtrWillBeRawPtr<Quad> quad = Quad::create();
-    quad->setTop(top);
-    quad->setRight(right);
-    quad->setBottom(bottom);
-    quad->setLeft(left);
+    quad->setTop(toCSSPrimitiveValue(*top));
+    quad->setRight(toCSSPrimitiveValue(*right));
+    quad->setBottom(toCSSPrimitiveValue(*bottom));
+    quad->setLeft(toCSSPrimitiveValue(*left));
 
     return cssValuePool().createValue(quad.release());
 }
 
 static CSSValueID valueForRepeatRule(int rule)
 {
     switch (rule) {
     case RepeatImageRule:
         return CSSValueRepeat;
     case RoundImageRule:
         return CSSValueRound;
     case SpaceImageRule:
         return CSSValueSpace;
     default:
         return CSSValueStretch;
     }
 }
 
 static CSSValue valueForNinePieceImageRepeat(const NinePieceImage& image)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> horizontalRepeat = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> verticalRepeat = nullptr;
+    NullableCSSValue horizontalRepeat;
+    NullableCSSValue verticalRepeat;
 
     horizontalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.horizontalRule()));
     if (image.horizontalRule() == image.verticalRule())
         verticalRepeat = horizontalRepeat;
     else
         verticalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.verticalRule()));
-    return cssValuePool().createValue(Pair::create(horizontalRepeat.release(), verticalRepeat.release(), Pair::DropIdenticalValues));
+    return cssValuePool().createValue(Pair::create(toCSSPrimitiveValue(*horizontalRepeat), toCSSPrimitiveValue(*verticalRepeat), Pair::DropIdenticalValues));
 }
 
 static CSSValue valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
 {
     if (!image.hasImage())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     // Image first.
     NullableCSSValue imageValue;
     if (image.image())
@@ skipping 12 matching lines @@
     CSSValue repeat = valueForNinePieceImageRepeat(image);
 
     return createBorderImageValue(imageValue, imageSlices, borderSlices, outset, repeat);
 }
 
 static CSSValue valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
 {
     if (!reflection)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> offset = nullptr;
+    NullableCSSValue offset;
     // TODO(alancutter): Make this work correctly for calc lengths.
     if (reflection->offset().hasPercent())
         offset = cssValuePool().createValue(reflection->offset().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
     else
         offset = zoomAdjustedPixelValue(reflection->offset().value(), style);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> direction = nullptr;
+    NullableCSSValue direction;
     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(toCSSPrimitiveValue(*direction), toCSSPrimitiveValue(*offset), valueForNinePieceImage(reflection->mask(), style));
 }
 
 static ItemPosition resolveAlignmentAuto(ItemPosition position, Node* element)
 {
     if (position != ItemPositionAuto)
         return position;
 
     return isFlexOrGrid(element) ? ItemPositionStretch : ItemPositionStart;
 }
 
@@ skipping 33 matching lines @@
 {
     RefPtrWillBeRawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
     const FillLayer* currLayer = &style.backgroundLayers();
     for (; currLayer; currLayer = currLayer->next()) {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
         RefPtrWillBeRawPtr<CSSValueList> beforeSlash = CSSValueList::createSpaceSeparated();
         if (!currLayer->next()) { // color only for final layer
             NullableCSSValue value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
             beforeSlash->append(*value);
         }
-        beforeSlash->append(currLayer->image() ? *currLayer->image()->cssValue() : cssValuePool().createIdentifierValue(CSSValueNone));
+        beforeSlash->append(currLayer->image() ? *currLayer->image()->cssValue() : CSSValue(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);
         RefPtrWillBeRawPtr<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);
@@ skipping 19 matching lines @@
         result->append(CSSPrimitiveValue::create(distribution));
     if (distribution == ContentDistributionDefault || position != ContentPositionAuto)
         result->append(CSSPrimitiveValue::create(position));
     if ((position >= ContentPositionCenter || distribution != ContentDistributionDefault) && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
     ASSERT(result->length() > 0);
     ASSERT(result->length() <= 3);
     return result.release();
 }
 
-static PassRefPtrWillBeRawPtr<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.fontDescription().specifiedSize()), 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 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFamily(const AtomicString& family)
+static CSSPrimitiveValue valueForFamily(const AtomicString& family)
 {
     if (CSSValueID familyIdentifier = identifierForFamily(family))
         return cssValuePool().createIdentifierValue(familyIdentifier);
     return cssValuePool().createValue(family.string(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForFontFamily(const ComputedStyle& style)
 {
     const FontFamily& firstFamily = style.fontDescription().family();
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     for (const FontFamily* family = &firstFamily; family; family = family->next())
         list->append(valueForFamily(family->family()));
     return list.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontSize(const ComputedStyle& style)
+static CSSPrimitiveValue valueForFontSize(const ComputedStyle& style)
 {
     return zoomAdjustedPixelValue(style.fontDescription().computedSize(), style);
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontStretch(const ComputedStyle& style)
+static CSSPrimitiveValue valueForFontStretch(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.fontDescription().stretch());
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontStyle(const ComputedStyle& style)
+static CSSPrimitiveValue valueForFontStyle(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.fontDescription().style());
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontVariant(const ComputedStyle& style)
+static CSSPrimitiveValue valueForFontVariant(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.fontDescription().variant());
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontWeight(const ComputedStyle& style)
+static CSSPrimitiveValue valueForFontWeight(const ComputedStyle& style)
 {
     return cssValuePool().createValue(style.fontDescription().weight());
 }
 
 static CSSValue specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
 {
     if (!trackBreadth.isLength())
         return cssValuePool().createValue(trackBreadth.flex(), CSSPrimitiveValue::CSS_FR);
 
     const Length& trackBreadthLength = trackBreadth.length();
@@ skipping 460 matching lines @@
     return CSSValueInvalid;
 }
 
 static CSSValue valueForContentData(const ComputedStyle& style)
 {
     RefPtrWillBeRawPtr<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);
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = cssValuePool().createValue(counter->identifier(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = cssValuePool().createValue(counter->separator(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
+            CSSPrimitiveValue identifier = cssValuePool().createValue(counter->identifier(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
+            CSSPrimitiveValue separator = cssValuePool().createValue(counter->separator(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
             CSSValueID listStyleIdent = CSSValueNone;
             if (counter->listStyle() != NoneListStyle)
                 listStyleIdent = static_cast<CSSValueID>(CSSValueDisc + counter->listStyle());
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
-            list->append(cssValuePool().createValue(Counter::create(identifier.release(), listStyle.release(), separator.release())));
+            CSSPrimitiveValue listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
+            list->append(cssValuePool().createValue(Counter::create(identifier, listStyle, separator)));
         } else if (contentData->isImage()) {
             const StyleImage* image = toImageContentData(contentData)->image();
             ASSERT(image);
             list->append(*image->cssValue());
         } else if (contentData->isText()) {
             list->append(cssValuePool().createValue(toTextContentData(contentData)->text(), CSSPrimitiveValue::CSS_STRING));
         } else if (contentData->isQuote()) {
             const QuoteType quoteType = toQuoteContentData(contentData)->quote();
             list->append(cssValuePool().createIdentifierValue(valueForQuoteType(quoteType)));
         } else {
@@ skipping 111 matching lines @@
         verticalRadii->append(bottomRightRadius->item(1));
     if (showVerticalBottomLeft)
         verticalRadii->append(bottomLeftRadius->item(1));
 
     if (!verticalRadii->equals(toCSSValueList(list->item(0))))
         list->append(verticalRadii.release());
 
     return list.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> glyphOrientationToCSSPrimitiveValue(EGlyphOrientation orientation)
+static NullableCSSValue glyphOrientationToCSSPrimitiveValue(EGlyphOrientation orientation)
 {
     switch (orientation) {
     case GO_0DEG:
         return CSSPrimitiveValue::create(0.0f, CSSPrimitiveValue::CSS_DEG);
     case GO_90DEG:
         return CSSPrimitiveValue::create(90.0f, CSSPrimitiveValue::CSS_DEG);
     case GO_180DEG:
         return CSSPrimitiveValue::create(180.0f, CSSPrimitiveValue::CSS_DEG);
     case GO_270DEG:
         return CSSPrimitiveValue::create(270.0f, CSSPrimitiveValue::CSS_DEG);
@@ skipping 56 matching lines @@
     return CSSPrimitiveValue::createColor(color.rgb());
 }
 
 static inline String serializeAsFragmentIdentifier(const AtomicString& resource)
 {
     return "#" + resource;
 }
 
 CSSValue ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
 {
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> x = zoomAdjustedPixelValue(shadow.x(), style);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> y = zoomAdjustedPixelValue(shadow.y(), style);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> blur = zoomAdjustedPixelValue(shadow.blur(), style);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : PassRefPtrWillBeRawPtr<CSSPrimitiveValue>(nullptr);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> shadowStyle = shadow.style() == Normal ? PassRefPtrWillBeRawPtr<CSSPrimitiveValue>(nullptr) : cssValuePool().createIdentifierValue(CSSValueInset);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> 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);
+    NullableCSSValue spread = useSpread ? NullableCSSValue(zoomAdjustedPixelValue(shadow.spread(), style)) : nullptr;
+    NullableCSSValue shadowStyle = shadow.style() == Normal ? nullptr : NullableCSSValue(cssValuePool().createIdentifierValue(CSSValueInset));
+    CSSPrimitiveValue color = currentColorOrValidColor(style, shadow.color());
+    return CSSShadowValue::create(x, y, blur, spread, shadowStyle, color);
 }
 
 CSSValue ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
 {
     if (!shadowList)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     size_t shadowCount = shadowList->shadows().size();
     for (size_t i = 0; i < shadowCount; ++i)
@@ skipping 1351 matching lines @@
             return zoomAdjustedPixelValueForLength(svgStyle.baselineShiftValue(), style);
         }
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     case CSSPropertyBufferedRendering:
         return CSSPrimitiveValue::create(svgStyle.bufferedRendering());
     case CSSPropertyGlyphOrientationHorizontal:
         return glyphOrientationToCSSPrimitiveValue(svgStyle.glyphOrientationHorizontal());
     case CSSPropertyGlyphOrientationVertical: {
-        if (RefPtrWillBeRawPtr<CSSPrimitiveValue> value = glyphOrientationToCSSPrimitiveValue(svgStyle.glyphOrientationVertical()))
-            return value.release();
+        if (NullableCSSValue value = glyphOrientationToCSSPrimitiveValue(svgStyle.glyphOrientationVertical()))
+            return value;
         if (svgStyle.glyphOrientationVertical() == GO_AUTO)
             return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
         return nullptr;
     }
     case CSSPropertyPaintOrder:
         return paintOrderToCSSValueList(svgStyle.paintOrder());
     case CSSPropertyVectorEffect:
         return CSSPrimitiveValue::create(svgStyle.vectorEffect());
     case CSSPropertyMaskType:
         return CSSPrimitiveValue::create(svgStyle.maskType());
@@ skipping 78 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 }