CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

Source/core/css/resolver/StyleBuilderConverter.cpp

Index: Source/core/css/resolver/StyleBuilderConverter.cpp
diff --git a/Source/core/css/resolver/StyleBuilderConverter.cpp b/Source/core/css/resolver/StyleBuilderConverter.cpp
index 5b3100b7772e60942fdb9a2595c383fa6009f278..305b1f5c3588f67db42db9b5e5cc3a7509e04499 100644
--- a/Source/core/css/resolver/StyleBuilderConverter.cpp
+++ b/Source/core/css/resolver/StyleBuilderConverter.cpp
@@ -64,7 +64,7 @@ static GridLength convertGridTrackBreadth(const StyleResolverState& state, CSSPr
 
 } // namespace
 
-PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolverState& state, CSSValue value)
+PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
@@ -83,21 +83,21 @@ PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolv
     return reflection.release();
 }
 
-Color StyleBuilderConverter::convertColor(StyleResolverState& state, CSSValue value, bool forVisitedLink)
+Color StyleBuilderConverter::convertColor(StyleResolverState& state, const CSSValue& value, bool forVisitedLink)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     return state.document().textLinkColors().colorFromPrimitiveValue(primitiveValue, state.style()->color(), forVisitedLink);
 }
 
-AtomicString StyleBuilderConverter::convertFragmentIdentifier(StyleResolverState& state, CSSValue value)
+AtomicString StyleBuilderConverter::convertFragmentIdentifier(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isURI())
         return SVGURIReference::fragmentIdentifierFromIRIString(primitiveValue.getStringValue(), state.element()->treeScope());
     return nullAtom;
 }
 
-LengthBox StyleBuilderConverter::convertClip(StyleResolverState& state, CSSValue value)
+LengthBox StyleBuilderConverter::convertClip(StyleResolverState& state, const CSSValue& value)
 {
     Rect* rect = toCSSPrimitiveValue(value).getRectValue();
 
@@ -143,7 +143,7 @@ static bool convertFontFamilyName(StyleResolverState& state, CSSPrimitiveValue p
     return !familyName.isEmpty();
 }
 
-FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(StyleResolverState& state, CSSValue value)
+FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(StyleResolverState& state, const CSSValue& value)
 {
     ASSERT(value.isValueList());
 
@@ -174,7 +174,7 @@ FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(Styl
     return desc;
 }
 
-PassRefPtr<FontFeatureSettings> StyleBuilderConverter::convertFontFeatureSettings(StyleResolverState& state, CSSValue value)
+PassRefPtr<FontFeatureSettings> StyleBuilderConverter::convertFontFeatureSettings(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNormal)
         return FontBuilder::initialFeatureSettings();
@@ -206,9 +206,9 @@ static float computeFontSize(StyleResolverState& state, CSSPrimitiveValue primit
     return 0;
 }
 
-FontDescription::Size StyleBuilderConverter::convertFontSize(StyleResolverState& state, CSSValue value)
+FontDescription::Size StyleBuilderConverter::convertFontSize(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
 
     FontDescription::Size parentSize(0, 0.0f, false);
 
@@ -245,9 +245,9 @@ FontDescription::Size StyleBuilderConverter::convertFontSize(StyleResolverState&
     return FontDescription::Size(0, computeFontSize(state, primitiveValue, parentSize), parentIsAbsoluteSize || !primitiveValue.isFontRelativeLength());
 }
 
-float StyleBuilderConverter::convertFontSizeAdjust(StyleResolverState& state, CSSValue value)
+float StyleBuilderConverter::convertFontSizeAdjust(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueNone)
         return FontBuilder::initialSizeAdjust();
 
@@ -255,9 +255,9 @@ float StyleBuilderConverter::convertFontSizeAdjust(StyleResolverState& state, CS
     return primitiveValue.getFloatValue();
 }
 
-FontWeight StyleBuilderConverter::convertFontWeight(StyleResolverState& state, CSSValue value)
+FontWeight StyleBuilderConverter::convertFontWeight(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue.getValueID()) {
     case CSSValueBolder:
         return FontDescription::bolderWeight(state.parentStyle()->fontDescription().weight());
@@ -268,14 +268,14 @@ FontWeight StyleBuilderConverter::convertFontWeight(StyleResolverState& state, C
     }
 }
 
-FontDescription::VariantLigatures StyleBuilderConverter::convertFontVariantLigatures(StyleResolverState&, CSSValue value)
+FontDescription::VariantLigatures StyleBuilderConverter::convertFontVariantLigatures(StyleResolverState&, const CSSValue& value)
 {
     if (value.isValueList()) {
         FontDescription::VariantLigatures ligatures;
         CSSValueList& valueList = toCSSValueList(value);
         for (size_t i = 0; i < valueList.length(); ++i) {
-            CSSValue item = valueList.item(i);
-            CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(item);
+            const CSSValue& item = valueList.item(i);
+            const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(item);
             switch (primitiveValue.getValueID()) {
             case CSSValueNoCommonLigatures:
                 ligatures.common = FontDescription::DisabledLigaturesState;
@@ -314,12 +314,12 @@ FontDescription::VariantLigatures StyleBuilderConverter::convertFontVariantLigat
     return FontDescription::VariantLigatures();
 }
 
-EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleResolverState&, CSSValue value)
+EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleResolverState&, const CSSValue& value)
 {
     if (!value.isPrimitiveValue())
         return GO_0DEG;
 
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.primitiveType() != CSSPrimitiveValue::CSS_DEG)
         return GO_0DEG;
 
@@ -334,17 +334,17 @@ EGlyphOrientation StyleBuilderConverter::convertGlyphOrientation(StyleResolverSt
     return GO_270DEG;
 }
 
-StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(StyleResolverState&, CSSValue value)
+StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(StyleResolverState&, const CSSValue& value)
 {
     StyleSelfAlignmentData alignmentData = ComputedStyle::initialSelfAlignment();
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (Pair* pairValue = primitiveValue.getPairValue()) {
-        if (toCSSPrimitiveValue(*pairValue->first()).getValueID() == CSSValueLegacy) {
+        if (pairValue->first().getValueID() == CSSValueLegacy) {
             alignmentData.setPositionType(LegacyPosition);
-            alignmentData.setPosition(toCSSPrimitiveValue(*pairValue->second()));
+            alignmentData.setPosition(pairValue->second());
         } else {
-            alignmentData.setPosition(toCSSPrimitiveValue(*pairValue->first()));
-            alignmentData.setOverflow(toCSSPrimitiveValue(*pairValue->second()));
+            alignmentData.setPosition(pairValue->first());
+            alignmentData.setOverflow(pairValue->second());
         }
     } else {
         alignmentData.setPosition(primitiveValue);
@@ -352,7 +352,7 @@ StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(
     return alignmentData;
 }
 
-StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolverState&, CSSValue value)
+StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolverState&, const CSSValue& value)
 {
     StyleContentAlignmentData alignmentData = ComputedStyle::initialContentAlignment();
     CSSContentDistributionValue& contentValue = toCSSContentDistributionValue(value);
@@ -365,25 +365,25 @@ StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(Sty
     return alignmentData;
 }
 
-GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolverState&, CSSValue value)
+GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolverState&, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
 
     ASSERT(list.length() >= 1);
-    CSSPrimitiveValue first = toCSSPrimitiveValue(list.item(0));
+    const CSSPrimitiveValue& first = toCSSPrimitiveValue(list.item(0));
     NullableCSSValue second = list.length() == 2 ? NullableCSSValue(list.item(1)) : nullptr;
 
     switch (first.getValueID()) {
     case CSSValueRow:
-        if (second && toCSSPrimitiveValue(*second).getValueID() == CSSValueDense)
+        if (second && toCSSPrimitiveValue(second).getValueID() == CSSValueDense)
             return AutoFlowRowDense;
         return AutoFlowRow;
     case CSSValueColumn:
-        if (second && toCSSPrimitiveValue(*second).getValueID() == CSSValueDense)
+        if (second && toCSSPrimitiveValue(second).getValueID() == CSSValueDense)
             return AutoFlowColumnDense;
         return AutoFlowColumn;
     case CSSValueDense:
-        if (second && toCSSPrimitiveValue(*second).getValueID() == CSSValueColumn)
+        if (second && toCSSPrimitiveValue(second).getValueID() == CSSValueColumn)
             return AutoFlowColumnDense;
         return AutoFlowRowDense;
     default:
@@ -392,7 +392,7 @@ GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolverState&, CSS
     }
 }
 
-GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSSValue value)
+GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, const CSSValue& value)
 {
     // We accept the specification's grammar:
     // 'auto' | [ <integer> || <custom-ident> ] | [ span && [ <integer> || <custom-ident> ] ] | <custom-ident>
@@ -400,7 +400,7 @@ GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSS
     GridPosition position;
 
     if (value.isPrimitiveValue()) {
-        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
         // We translate <custom-ident> to <string> during parsing as it
         // makes handling it more simple.
         if (primitiveValue.isCustomIdent()) {
@@ -422,20 +422,20 @@ GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSS
 
     auto it = values.begin();
     NullableCSSValue currentValue = *it;
-    if (toCSSPrimitiveValue(*currentValue).getValueID() == CSSValueSpan) {
+    if (toCSSPrimitiveValue(currentValue).getValueID() == CSSValueSpan) {
         isSpanPosition = true;
         ++it;
         currentValue = it != values.end() ? *it : NullableCSSValue();
     }
 
-    if (currentValue && toCSSPrimitiveValue(*currentValue).isNumber()) {
-        gridLineNumber = toCSSPrimitiveValue(*currentValue).getIntValue();
+    if (currentValue && toCSSPrimitiveValue(currentValue).isNumber()) {
+        gridLineNumber = toCSSPrimitiveValue(currentValue).getIntValue();
         ++it;
         currentValue = it != values.end() ? *it : NullableCSSValue();
     }
 
-    if (currentValue && toCSSPrimitiveValue(*currentValue).isCustomIdent()) {
-        gridLineName = toCSSPrimitiveValue(*currentValue).getStringValue();
+    if (currentValue && toCSSPrimitiveValue(currentValue).isCustomIdent()) {
+        gridLineName = toCSSPrimitiveValue(currentValue).getStringValue();
         ++it;
     }
 
@@ -448,7 +448,7 @@ GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSS
     return position;
 }
 
-GridTrackSize StyleBuilderConverter::convertGridTrackSize(StyleResolverState& state, CSSValue value)
+GridTrackSize StyleBuilderConverter::convertGridTrackSize(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPrimitiveValue())
         return GridTrackSize(convertGridTrackBreadth(state, toCSSPrimitiveValue(value)));
@@ -460,11 +460,11 @@ GridTrackSize StyleBuilderConverter::convertGridTrackSize(StyleResolverState& st
     return GridTrackSize(minTrackBreadth, maxTrackBreadth);
 }
 
-bool StyleBuilderConverter::convertGridTrackList(CSSValue value, Vector<GridTrackSize>& trackSizes, NamedGridLinesMap& namedGridLines, OrderedNamedGridLines& orderedNamedGridLines, StyleResolverState& state)
+bool StyleBuilderConverter::convertGridTrackList(const CSSValue& value, Vector<GridTrackSize>& trackSizes, NamedGridLinesMap& namedGridLines, OrderedNamedGridLines& orderedNamedGridLines, StyleResolverState& state)
 {
     // Handle 'none'.
     if (value.isPrimitiveValue()) {
-        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
         return primitiveValue.getValueID() == CSSValueNone;
     }
 
@@ -531,27 +531,27 @@ void StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(const Named
     }
 }
 
-Length StyleBuilderConverter::convertLength(const StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertLength(const StyleResolverState& state, const CSSValue& value)
 {
     return toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData());
 }
 
-UnzoomedLength StyleBuilderConverter::convertUnzoomedLength(const StyleResolverState& state, CSSValue value)
+UnzoomedLength StyleBuilderConverter::convertUnzoomedLength(const StyleResolverState& state, const CSSValue& value)
 {
     return UnzoomedLength(toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)));
 }
 
-Length StyleBuilderConverter::convertLengthOrAuto(const StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertLengthOrAuto(const StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueAuto)
         return Length(Auto);
     return primitiveValue.convertToLength(state.cssToLengthConversionData());
 }
 
-Length StyleBuilderConverter::convertLengthSizing(StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertLengthSizing(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue.getValueID()) {
     case CSSValueInvalid:
         return convertLength(state, value);
@@ -577,23 +577,23 @@ Length StyleBuilderConverter::convertLengthSizing(StyleResolverState& state, CSS
     }
 }
 
-Length StyleBuilderConverter::convertLengthMaxSizing(StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertLengthMaxSizing(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueNone)
         return Length(MaxSizeNone);
     return convertLengthSizing(state, value);
 }
 
-TabSize StyleBuilderConverter::convertLengthOrTabSpaces(StyleResolverState& state, CSSValue value)
+TabSize StyleBuilderConverter::convertLengthOrTabSpaces(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isNumber())
         return TabSize(primitiveValue.getIntValue());
     return TabSize(primitiveValue.computeLength<float>(state.cssToLengthConversionData()));
 }
 
-LineBoxContain StyleBuilderConverter::convertLineBoxContain(StyleResolverState&, CSSValue value)
+LineBoxContain StyleBuilderConverter::convertLineBoxContain(StyleResolverState&, const CSSValue& value)
 {
     if (value.isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
@@ -611,9 +611,9 @@ static CSSToLengthConversionData lineHeightToLengthConversionData(StyleResolverS
     return state.cssToLengthConversionData().copyWithAdjustedZoom(multiplier);
 }
 
-Length StyleBuilderConverter::convertLineHeight(StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertLineHeight(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue.isLength())
         return primitiveValue.computeLength<Length>(lineHeightToLengthConversionData(state));
@@ -630,9 +630,9 @@ Length StyleBuilderConverter::convertLineHeight(StyleResolverState& state, CSSVa
     return ComputedStyle::initialLineHeight();
 }
 
-float StyleBuilderConverter::convertNumberOrPercentage(StyleResolverState& state, CSSValue value)
+float StyleBuilderConverter::convertNumberOrPercentage(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     ASSERT(primitiveValue.isNumber() || primitiveValue.isPercentage());
     if (primitiveValue.isNumber())
         return primitiveValue.getFloatValue();
@@ -643,23 +643,23 @@ template <CSSValueID cssValueFor0, CSSValueID cssValueFor100>
 static Length convertPositionLength(StyleResolverState& state, CSSPrimitiveValue primitiveValue)
 {
     if (Pair* pair = primitiveValue.getPairValue()) {
-        Length length = StyleBuilderConverter::convertLength(state, CSSValue(*pair->second()));
-        if (toCSSPrimitiveValue(*pair->first()).getValueID() == cssValueFor0)
+        Length length = StyleBuilderConverter::convertLength(state, CSSValue(pair->second()));
+        if (pair->first().getValueID() == cssValueFor0)
             return length;
-        ASSERT(toCSSPrimitiveValue(*pair->first()).getValueID() == cssValueFor100);
+        ASSERT(pair->first().getValueID() == cssValueFor100);
         return length.subtractFromOneHundredPercent();
     }
 
     return StyleBuilderConverter::convertLength(state, primitiveValue);
 }
 
-LengthPoint StyleBuilderConverter::convertPosition(StyleResolverState& state, CSSValue value)
+LengthPoint StyleBuilderConverter::convertPosition(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue.getPairValue();
     return LengthPoint(
-        convertPositionLength<CSSValueLeft, CSSValueRight>(state, toCSSPrimitiveValue(*pair->first())),
-        convertPositionLength<CSSValueTop, CSSValueBottom>(state, toCSSPrimitiveValue(*pair->second()))
+        convertPositionLength<CSSValueLeft, CSSValueRight>(state, pair->first()),
+        convertPositionLength<CSSValueTop, CSSValueBottom>(state, pair->second())
     );
 }
 
@@ -668,9 +668,9 @@ static float convertPerspectiveLength(StyleResolverState& state, CSSPrimitiveVal
     return std::max(primitiveValue.computeLength<float>(state.cssToLengthConversionData()), 0.0f);
 }
 
-float StyleBuilderConverter::convertPerspective(StyleResolverState& state, CSSValue value)
+float StyleBuilderConverter::convertPerspective(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue.getValueID() == CSSValueNone)
         return ComputedStyle::initialPerspective();
@@ -696,13 +696,13 @@ static Length convertOriginLength(StyleResolverState& state, CSSPrimitiveValue p
     return StyleBuilderConverter::convertLength(state, CSSValue(primitiveValue));
 }
 
-LengthPoint StyleBuilderConverter::convertPerspectiveOrigin(StyleResolverState& state, CSSValue value)
+LengthPoint StyleBuilderConverter::convertPerspectiveOrigin(StyleResolverState& state, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() == 2);
 
-    CSSPrimitiveValue primitiveValueX = toCSSPrimitiveValue(list.item(0));
-    CSSPrimitiveValue primitiveValueY = toCSSPrimitiveValue(list.item(1));
+    const CSSPrimitiveValue& primitiveValueX = toCSSPrimitiveValue(list.item(0));
+    const CSSPrimitiveValue& primitiveValueY = toCSSPrimitiveValue(list.item(1));
 
     return LengthPoint(
         convertOriginLength<CSSValueLeft, CSSValueRight>(state, primitiveValueX),
@@ -710,7 +710,7 @@ LengthPoint StyleBuilderConverter::convertPerspectiveOrigin(StyleResolverState&
     );
 }
 
-EPaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolverState&, CSSValue cssPaintOrder)
+EPaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolverState&, const CSSValue& cssPaintOrder)
 {
     if (cssPaintOrder.isValueList()) {
         int paintOrder = 0;
@@ -740,7 +740,7 @@ EPaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolverState&, CSSVal
     return PO_NORMAL;
 }
 
-Length StyleBuilderConverter::convertQuirkyLength(StyleResolverState& state, CSSValue value)
+Length StyleBuilderConverter::convertQuirkyLength(StyleResolverState& state, const CSSValue& value)
 {
     Length length = convertLengthOrAuto(state, value);
     // This is only for margins which use __qem
@@ -748,7 +748,7 @@ Length StyleBuilderConverter::convertQuirkyLength(StyleResolverState& state, CSS
     return length;
 }
 
-PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolverState&, CSSValue value)
+PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolverState&, const CSSValue& value)
 {
     if (value.isValueList()) {
         CSSValueList& list = toCSSValueList(value);
@@ -766,12 +766,12 @@ PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolverState&,
     return QuotesData::create();
 }
 
-LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, CSSValue value)
+LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue.getPairValue();
-    Length radiusWidth = toCSSPrimitiveValue(*pair->first()).convertToLength(state.cssToLengthConversionData());
-    Length radiusHeight = toCSSPrimitiveValue(*pair->second()).convertToLength(state.cssToLengthConversionData());
+    Length radiusWidth = pair->first().convertToLength(state.cssToLengthConversionData());
+    Length radiusHeight = pair->second().convertToLength(state.cssToLengthConversionData());
     float width = radiusWidth.value();
     float height = radiusHeight.value();
     ASSERT(width >= 0 && height >= 0);
@@ -780,7 +780,7 @@ LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, CSSVa
     return LengthSize(radiusWidth, radiusHeight);
 }
 
-PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState& state, CSSValue value)
+PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
@@ -792,11 +792,11 @@ PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState&
     ShadowDataVector shadows;
     for (size_t i = 0; i < shadowCount; ++i) {
         const CSSShadowValue& item = toCSSShadowValue(valueList.item(i));
-        float x = toCSSPrimitiveValue(*item.x).computeLength<float>(state.cssToLengthConversionData());
-        float y = toCSSPrimitiveValue(*item.y).computeLength<float>(state.cssToLengthConversionData());
-        float blur = item.blur ? toCSSPrimitiveValue(*item.blur).computeLength<float>(state.cssToLengthConversionData()) : 0;
-        float spread = item.spread ? toCSSPrimitiveValue(*item.spread).computeLength<float>(state.cssToLengthConversionData()) : 0;
-        ShadowStyle shadowStyle = item.style && toCSSPrimitiveValue(*item.style).getValueID() == CSSValueInset ? Inset : Normal;
+        float x = toCSSPrimitiveValue(item.x).computeLength<float>(state.cssToLengthConversionData());
+        float y = toCSSPrimitiveValue(item.y).computeLength<float>(state.cssToLengthConversionData());
+        float blur = item.blur ? toCSSPrimitiveValue(item.blur).computeLength<float>(state.cssToLengthConversionData()) : 0;
+        float spread = item.spread ? toCSSPrimitiveValue(item.spread).computeLength<float>(state.cssToLengthConversionData()) : 0;
+        ShadowStyle shadowStyle = item.style && toCSSPrimitiveValue(item.style).getValueID() == CSSValueInset ? Inset : Normal;
         StyleColor color = StyleColor::currentColor();
         if (item.color)
             color = convertStyleColor(state, CSSValue(*item.color));
@@ -805,7 +805,7 @@ PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState&
     return ShadowList::adopt(shadows);
 }
 
-PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleResolverState& state, CSSValue value)
+PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
@@ -819,7 +819,7 @@ PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleResolverSta
     CSSBoxType cssBox = BoxMissing;
     CSSValueList& valueList = toCSSValueList(value);
     for (unsigned i = 0; i < valueList.length(); ++i) {
-        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(valueList.item(i));
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(valueList.item(i));
         if (primitiveValue.isShape())
             shape = basicShapeForValue(state, primitiveValue.getShapeValue());
         else
@@ -833,15 +833,15 @@ PassRefPtr<ShapeValue> StyleBuilderConverter::convertShapeValue(StyleResolverSta
     return ShapeValue::createBoxShapeValue(cssBox);
 }
 
-float StyleBuilderConverter::convertSpacing(StyleResolverState& state, CSSValue value)
+float StyleBuilderConverter::convertSpacing(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueNormal)
         return 0;
     return primitiveValue.computeLength<float>(state.cssToLengthConversionData());
 }
 
-PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleResolverState& state, CSSValue value)
+PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleResolverState& state, const CSSValue& value)
 {
     if (!value.isValueList())
         return SVGComputedStyle::initialStrokeDashArray();
@@ -861,17 +861,17 @@ PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleReso
     return array.release();
 }
 
-StyleColor StyleBuilderConverter::convertStyleColor(StyleResolverState& state, CSSValue value, bool forVisitedLink)
+StyleColor StyleBuilderConverter::convertStyleColor(StyleResolverState& state, const CSSValue& value, bool forVisitedLink)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueCurrentcolor)
         return StyleColor::currentColor();
     return state.document().textLinkColors().colorFromPrimitiveValue(primitiveValue, Color(), forVisitedLink);
 }
 
-float StyleBuilderConverter::convertTextStrokeWidth(StyleResolverState& state, CSSValue value)
+float StyleBuilderConverter::convertTextStrokeWidth(StyleResolverState& state, const CSSValue& value)
 {
-    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID()) {
         float multiplier = convertLineWidth<float>(state, value);
         return CSSPrimitiveValue::create(multiplier / 48, CSSPrimitiveValue::CSS_EMS).computeLength<float>(state.cssToLengthConversionData());
@@ -879,13 +879,13 @@ float StyleBuilderConverter::convertTextStrokeWidth(StyleResolverState& state, C
     return primitiveValue.computeLength<float>(state.cssToLengthConversionData());
 }
 
-TransformOrigin StyleBuilderConverter::convertTransformOrigin(StyleResolverState& state, CSSValue value)
+TransformOrigin StyleBuilderConverter::convertTransformOrigin(StyleResolverState& state, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() == 3);
 
-    CSSPrimitiveValue primitiveValueX = toCSSPrimitiveValue(list.item(0));
-    CSSPrimitiveValue primitiveValueY = toCSSPrimitiveValue(list.item(1));
+    const CSSPrimitiveValue& primitiveValueX = toCSSPrimitiveValue(list.item(0));
+    const CSSPrimitiveValue& primitiveValueY = toCSSPrimitiveValue(list.item(1));
 
     return TransformOrigin(
         convertOriginLength<CSSValueLeft, CSSValueRight>(state, primitiveValueX),
@@ -894,7 +894,7 @@ TransformOrigin StyleBuilderConverter::convertTransformOrigin(StyleResolverState
     );
 }
 
-ScrollSnapPoints StyleBuilderConverter::convertSnapPoints(StyleResolverState& state, CSSValue value)
+ScrollSnapPoints StyleBuilderConverter::convertSnapPoints(StyleResolverState& state, const CSSValue& value)
 {
     // Handles: none | repeat(<length>)
     ScrollSnapPoints points;
@@ -911,7 +911,7 @@ ScrollSnapPoints StyleBuilderConverter::convertSnapPoints(StyleResolverState& st
     return points;
 }
 
-Vector<LengthPoint> StyleBuilderConverter::convertSnapCoordinates(StyleResolverState& state, CSSValue value)
+Vector<LengthPoint> StyleBuilderConverter::convertSnapCoordinates(StyleResolverState& state, const CSSValue& value)
 {
     // Handles: none | <position>#
     Vector<LengthPoint> coordinates;
@@ -928,7 +928,7 @@ Vector<LengthPoint> StyleBuilderConverter::convertSnapCoordinates(StyleResolverS
     return coordinates;
 }
 
-PassRefPtr<TranslateTransformOperation> StyleBuilderConverter::convertTranslate(StyleResolverState& state, CSSValue value)
+PassRefPtr<TranslateTransformOperation> StyleBuilderConverter::convertTranslate(StyleResolverState& state, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() <= 3);
@@ -943,7 +943,7 @@ PassRefPtr<TranslateTransformOperation> StyleBuilderConverter::convertTranslate(
     return TranslateTransformOperation::create(tx, ty, tz, TransformOperation::Translate3D);
 }
 
-PassRefPtr<RotateTransformOperation> StyleBuilderConverter::convertRotate(StyleResolverState& state, CSSValue value)
+PassRefPtr<RotateTransformOperation> StyleBuilderConverter::convertRotate(StyleResolverState& state, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() == 1 || list.length() == 4);
@@ -960,7 +960,7 @@ PassRefPtr<RotateTransformOperation> StyleBuilderConverter::convertRotate(StyleR
     return RotateTransformOperation::create(x, y, z, angle, TransformOperation::Rotate3D);
 }
 
-PassRefPtr<ScaleTransformOperation> StyleBuilderConverter::convertScale(StyleResolverState& state, CSSValue value)
+PassRefPtr<ScaleTransformOperation> StyleBuilderConverter::convertScale(StyleResolverState& state, const CSSValue& value)
 {
     CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() <= 3);