CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

Source/core/css/CSSGradientValue.cpp

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 174 matching lines @@
             newStops[y].color = blend(leftColor, rightColor, weighting);
         }
 
         // Replace the color hint with the new color stops.
         stops.remove(x);
         stops.insert(x, newStops, 9);
         indexOffset += 8;
     }
 }
 
-static Color resolveStopColor(CSSPrimitiveValue stopColor, const LayoutObject& object)
+static Color resolveStopColor(const CSSPrimitiveValue& stopColor, const LayoutObject& object)
 {
     return object.document().textLinkColors().colorFromPrimitiveValue(stopColor, object.resolveColor(CSSPropertyColor));
 }
 
 void CSSGradientValue::addDeprecatedStops(Gradient* gradient, const LayoutObject& object)
 {
     ASSERT(m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient);
 
     if (!m_stopsSorted) {
         if (m_stops.size())
@@ skipping 166 matching lines @@
 
     for (size_t i = 0; i < numStops; ++i) {
         const CSSGradientColorStop& stop = m_stops[i];
 
         if (stop.isHint())
             hasHints = true;
         else
             stops[i].color = resolveStopColor(toCSSPrimitiveValue(*stop.m_color), object);
 
         if (stop.m_position) {
-            CSSPrimitiveValue stopPosition = toCSSPrimitiveValue(*stop.m_position);
+            const CSSPrimitiveValue& stopPosition = toCSSPrimitiveValue(*stop.m_position);
             if (stopPosition.isPercentage()) {
                 stops[i].offset = toCSSPrimitiveValue(*stop.m_position).getFloatValue() / 100;
             } else if (stopPosition.isLength() || stopPosition.isCalculatedPercentageWithLength()) {
                 float length;
                 if (stopPosition.isLength())
                     length = stopPosition.computeLength<float>(conversionData);
                 else
                     length = stopPosition.cssCalcValue()->toCalcValue(conversionData)->evaluate(gradientLength);
                 stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
             } else {
@@ skipping 81 matching lines @@
         } else {
             // Normalization failed because the stop set is coincident.
         }
     } else {
         // No normalization required, just add the current stops.
         for (const auto& stop : stops)
             gradient->addColorStop(stop.offset, stop.color);
     }
 }
 
-static float positionFromValue(CSSPrimitiveValue value, const CSSToLengthConversionData& conversionData, const IntSize& size, bool isHorizontal)
+static float positionFromValue(const CSSPrimitiveValue& value, const CSSToLengthConversionData& conversionData, const IntSize& size, bool isHorizontal)
 {
     int origin = 0;
     int sign = 1;
     int edgeDistance = isHorizontal ? size.width() : size.height();
 
     // In this case the center of the gradient is given relative to an edge in the form of:
     // [ top | bottom | right | left ] [ <percentage> | <length> ].
-    if (Pair* pair = value.getPairValue()) {
-        CSSValueID originID = toCSSPrimitiveValue(*pair->first()).getValueID();
-        value = toCSSPrimitiveValue(*pair->second());
+    CSSPrimitiveValue valueToUse = value;
+    if (Pair* pair = valueToUse.getPairValue()) {
+        CSSValueID originID = pair->first().getValueID();
+        valueToUse = pair->second();
 
         if (originID == CSSValueRight || originID == CSSValueBottom) {
             // For right/bottom, the offset is relative to the far edge.
             origin = edgeDistance;
             sign = -1;
         }
     }
 
-    if (value.isNumber())
-        return origin + sign * value.getFloatValue() * conversionData.zoom();
+    if (valueToUse.isNumber())
+        return origin + sign * valueToUse.getFloatValue() * conversionData.zoom();
 
-    if (value.isPercentage())
-        return origin + sign * value.getFloatValue() / 100.f * edgeDistance;
+    if (valueToUse.isPercentage())
+        return origin + sign * valueToUse.getFloatValue() / 100.f * edgeDistance;
 
-    if (value.isCalculatedPercentageWithLength())
-        return origin + sign * value.cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);
+    if (valueToUse.isCalculatedPercentageWithLength())
+        return origin + sign * valueToUse.cssCalcValue()->toCalcValue(conversionData)->evaluate(edgeDistance);
 
-    switch (value.getValueID()) {
+    switch (valueToUse.getValueID()) {
     case CSSValueTop:
         ASSERT(!isHorizontal);
         return 0;
     case CSSValueLeft:
         ASSERT(isHorizontal);
         return 0;
     case CSSValueBottom:
         ASSERT(!isHorizontal);
         return size.height();
     case CSSValueRight:
         ASSERT(isHorizontal);
         return size.width();
     default:
         break;
     }
 
-    return origin + sign * value.computeLength<float>(conversionData);
+    return origin + sign * valueToUse.computeLength<float>(conversionData);
 }
 
 FloatPoint CSSGradientValue::computeEndPoint(NullableCSSValue horizontal, NullableCSSValue vertical, const CSSToLengthConversionData& conversionData, const IntSize& size)
 {
     FloatPoint result;
 
     if (horizontal)
         result.setX(positionFromValue(toCSSPrimitiveValue(*horizontal), conversionData, size, true));
 
     if (vertical)
@@ skipping 452 matching lines @@
             if (stop.m_position)
                 result.append(stop.m_position->cssText());
         }
 
     }
 
     result.append(')');
     return result.toString();
 }
 
-float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue radius, const CSSToLengthConversionData& conversionData, float* widthOrHeight)
+float CSSRadialGradientValue::resolveRadius(const CSSPrimitiveValue& radius, const CSSToLengthConversionData& conversionData, float* widthOrHeight)
 {
     float result = 0;
     if (radius.isNumber()) // Can the radius be a percentage?
         result = radius.getFloatValue() * conversionData.zoom();
     else if (widthOrHeight && radius.isPercentage())
         result = *widthOrHeight * radius.getFloatValue() / 100;
     else
         result = radius.computeLength<float>(conversionData);
 
     return std::max(result, 0.0f);
@@ skipping 193 matching lines @@
     visitor->trace(m_firstRadius);
     visitor->trace(m_secondRadius);
     visitor->trace(m_shape);
     visitor->trace(m_sizingBehavior);
     visitor->trace(m_endHorizontalSize);
     visitor->trace(m_endVerticalSize);
     CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink