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 69 matching lines @@
     RefPtr<Image> newImage = GradientGeneratedImage::create(gradient, size);
     if (cacheable)
         putImage(size, newImage);
 
     return newImage.release();
 }
 
 // Should only ever be called for deprecated gradients.
 static inline bool compareStops(const CSSGradientColorStop& a, const CSSGradientColorStop& b)
 {
-    double aVal = toCSSPrimitiveValue(*a.m_position).getDoubleValue();
-    double bVal = toCSSPrimitiveValue(*b.m_position).getDoubleValue();
+    double aVal = toCSSPrimitiveValue(a.m_position).getDoubleValue();
+    double bVal = toCSSPrimitiveValue(b.m_position).getDoubleValue();
 
     return aVal < bVal;
 }
 
 struct GradientStop {
     Color color;
     float offset;
     bool specified;
 
     GradientStop()
@@ skipping 100 matching lines @@
     ASSERT(m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient);
 
     if (!m_stopsSorted) {
         if (m_stops.size())
             std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
         m_stopsSorted = true;
     }
 
     for (const auto& stop : m_stops) {
         float offset;
-        if (toCSSPrimitiveValue(*stop.m_position).isPercentage())
-            offset = toCSSPrimitiveValue(*stop.m_position).getFloatValue() / 100;
+        if (toCSSPrimitiveValue(stop.m_position).isPercentage())
+            offset = toCSSPrimitiveValue(stop.m_position).getFloatValue() / 100;
         else
-            offset = toCSSPrimitiveValue(*stop.m_position).getFloatValue();
+            offset = toCSSPrimitiveValue(stop.m_position).getFloatValue();
 
-        gradient->addColorStop(offset, resolveStopColor(toCSSPrimitiveValue(*stop.m_color), object));
+        gradient->addColorStop(offset, resolveStopColor(toCSSPrimitiveValue(stop.m_color), object));
     }
 }
 
 static bool requiresStopsNormalization(const Vector<GradientStop>& stops, const Gradient* gradient)
 {
     // We need at least two stops to normalize
     if (stops.size() < 2)
         return false;
 
     // Repeating gradients are implemented using a normalized stop offset range
@@ skipping 141 matching lines @@
     else if (isRadialGradientValue())
         gradientEnd = gradientStart + FloatSize(gradient->endRadius(), 0);
     float gradientLength = FloatSize(gradientStart - gradientEnd).diagonalLength();
 
     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);
+            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;
+                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 {
                 ASSERT_NOT_REACHED();
                 stops[i].offset = 0;
@@ skipping 88 matching lines @@
 
 static float positionFromValue(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());
+        CSSValueID originID = pair->first().getValueID();
+        value = 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();
@@ skipping 22 matching lines @@
     }
 
     return origin + sign * value.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));
+        result.setX(positionFromValue(toCSSPrimitiveValue(horizontal), conversionData, size, true));
 
     if (vertical)
-        result.setY(positionFromValue(toCSSPrimitiveValue(*vertical), conversionData, size, false));
+        result.setY(positionFromValue(toCSSPrimitiveValue(vertical), conversionData, size, false));
 
     return result;
 }
 
 bool CSSGradientValue::isCacheable() const
 {
     for (size_t i = 0; i < m_stops.size(); ++i) {
         const CSSGradientColorStop& stop = m_stops[i];
 
-        if (!stop.isHint() && toCSSPrimitiveValue(*stop.m_color).colorIsDerivedFromElement())
+        if (!stop.isHint() && toCSSPrimitiveValue(stop.m_color).colorIsDerivedFromElement())
             return false;
 
         if (!stop.m_position)
             continue;
 
-        if (toCSSPrimitiveValue(*stop.m_position).isFontRelativeLength())
+        if (toCSSPrimitiveValue(stop.m_position).isFontRelativeLength())
             return false;
     }
 
     return true;
 }
 
 bool CSSGradientValue::knownToBeOpaque(const LayoutObject* object) const
 {
     ASSERT(object);
     for (auto& stop : m_stops) {
-        if (!stop.isHint() && resolveStopColor(toCSSPrimitiveValue(*stop.m_color), *object).hasAlpha())
+        if (!stop.isHint() && resolveStopColor(toCSSPrimitiveValue(stop.m_color), *object).hasAlpha())
             return false;
     }
     return true;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSGradientValue)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_firstX);
     visitor->trace(m_firstY);
@@ skipping 49 matching lines @@
             }
         }
     } else {
         if (m_repeating)
             result.appendLiteral("repeating-linear-gradient(");
         else
             result.appendLiteral("linear-gradient(");
 
         bool wroteSomething = false;
 
-        if (m_angle && toCSSPrimitiveValue(*m_angle).computeDegrees() != 180) {
+        if (m_angle && toCSSPrimitiveValue(m_angle).computeDegrees() != 180) {
             result.append(m_angle->cssText());
             wroteSomething = true;
-        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && toCSSPrimitiveValue(*m_firstY).getValueID() == CSSValueBottom)) {
+        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && toCSSPrimitiveValue(m_firstY).getValueID() == CSSValueBottom)) {
             result.appendLiteral("to ");
             if (m_firstX && m_firstY) {
                 result.append(m_firstX->cssText());
                 result.append(' ');
                 result.append(m_firstY->cssText());
             } else if (m_firstX)
                 result.append(m_firstX->cssText());
             else
                 result.append(m_firstY->cssText());
             wroteSomething = true;
@@ skipping 88 matching lines @@
     firstPoint.set(halfWidth - endX, halfHeight + endY);
 }
 
 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(const CSSToLengthConversionData& conversionData, const IntSize& size, const LayoutObject& object)
 {
     ASSERT(!size.isEmpty());
 
     FloatPoint firstPoint;
     FloatPoint secondPoint;
     if (m_angle) {
-        float angle = toCSSPrimitiveValue(*m_angle).computeDegrees();
+        float angle = toCSSPrimitiveValue(m_angle).computeDegrees();
         endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
     } else {
         switch (m_gradientType) {
         case CSSDeprecatedLinearGradient:
             firstPoint = computeEndPoint(m_firstX, m_firstY, conversionData, size);
             if (m_secondX || m_secondY)
                 secondPoint = computeEndPoint(m_secondX, m_secondY, conversionData, size);
             else {
                 if (m_firstX)
                     secondPoint.setX(size.width() - firstPoint.x());
                 if (m_firstY)
                     secondPoint.setY(size.height() - firstPoint.y());
             }
             break;
         case CSSPrefixedLinearGradient:
             firstPoint = computeEndPoint(m_firstX, m_firstY, conversionData, size);
             if (m_firstX)
                 secondPoint.setX(size.width() - firstPoint.x());
             if (m_firstY)
                 secondPoint.setY(size.height() - firstPoint.y());
             break;
         case CSSLinearGradient:
             if (m_firstX && m_firstY) {
                 // "Magic" corners, so the 50% line touches two corners.
                 float rise = size.width();
                 float run = size.height();
-                if (m_firstX && toCSSPrimitiveValue(*m_firstX).getValueID() == CSSValueLeft)
+                if (m_firstX && toCSSPrimitiveValue(m_firstX).getValueID() == CSSValueLeft)
                     run *= -1;
-                if (m_firstY && toCSSPrimitiveValue(*m_firstY).getValueID() == CSSValueBottom)
+                if (m_firstY && toCSSPrimitiveValue(m_firstY).getValueID() == CSSValueBottom)
                     rise *= -1;
                 // Compute angle, and flip it back to "bearing angle" degrees.
                 float angle = 90 - rad2deg(atan2(rise, run));
                 endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
             } else if (m_firstX || m_firstY) {
                 secondPoint = computeEndPoint(m_firstX, m_firstY, conversionData, size);
                 if (m_firstX)
                     firstPoint.setX(size.width() - secondPoint.x());
                 if (m_firstY)
                     firstPoint.setY(size.height() - secondPoint.y());
@@ skipping 53 matching lines @@
 {
     visitor->trace(m_angle);
     CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 inline void CSSGradientValue::appendCSSTextForDeprecatedColorStops(StringBuilder& result) const
 {
     for (unsigned i = 0; i < m_stops.size(); i++) {
         const CSSGradientColorStop& stop = m_stops[i];
         result.appendLiteral(", ");
-        double stopValue = toCSSPrimitiveValue(*stop.m_position).getDoubleValue();
+        double stopValue = toCSSPrimitiveValue(stop.m_position).getDoubleValue();
         if (stopValue == 0) {
             result.appendLiteral("from(");
             result.append(stop.m_color->cssText());
             result.append(')');
         } else if (stopValue == 1) {
             result.appendLiteral("to(");
             result.append(stop.m_color->cssText());
             result.append(')');
         } else {
             result.appendLiteral("color-stop(");
@@ skipping 72 matching lines @@
     } else {
         if (m_repeating)
             result.appendLiteral("repeating-radial-gradient(");
         else
             result.appendLiteral("radial-gradient(");
 
         bool wroteSomething = false;
 
         // The only ambiguous case that needs an explicit shape to be provided
         // is when a sizing keyword is used (or all sizing is omitted).
-        if (m_shape && toCSSPrimitiveValue(*m_shape).getValueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
+        if (m_shape && toCSSPrimitiveValue(m_shape).getValueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
             result.appendLiteral("circle");
             wroteSomething = true;
         }
 
-        if (m_sizingBehavior && toCSSPrimitiveValue(*m_sizingBehavior).getValueID() != CSSValueFarthestCorner) {
+        if (m_sizingBehavior && toCSSPrimitiveValue(m_sizingBehavior).getValueID() != CSSValueFarthestCorner) {
             if (wroteSomething)
                 result.append(' ');
             result.append(m_sizingBehavior->cssText());
             wroteSomething = true;
         } else if (m_endHorizontalSize) {
             if (wroteSomething)
                 result.append(' ');
             result.append(m_endHorizontalSize->cssText());
             if (m_endVerticalSize) {
                 result.append(' ');
@@ skipping 134 matching lines @@
         firstPoint.setY(size.height() / 2);
 
     FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
     if (!m_secondX)
         secondPoint.setX(size.width() / 2);
     if (!m_secondY)
         secondPoint.setY(size.height() / 2);
 
     float firstRadius = 0;
     if (m_firstRadius)
-        firstRadius = resolveRadius(toCSSPrimitiveValue(*m_firstRadius), conversionData);
+        firstRadius = resolveRadius(toCSSPrimitiveValue(m_firstRadius), conversionData);
 
     FloatSize secondRadius(0, 0);
     if (m_secondRadius) {
-        secondRadius.setWidth(resolveRadius(toCSSPrimitiveValue(*m_secondRadius), conversionData));
+        secondRadius.setWidth(resolveRadius(toCSSPrimitiveValue(m_secondRadius), conversionData));
         secondRadius.setHeight(secondRadius.width());
     } else if (m_endHorizontalSize) {
         float width = size.width();
         float height = size.height();
-        secondRadius.setWidth(resolveRadius(toCSSPrimitiveValue(*m_endHorizontalSize), conversionData, &width));
+        secondRadius.setWidth(resolveRadius(toCSSPrimitiveValue(m_endHorizontalSize), conversionData, &width));
         secondRadius.setHeight(m_endVerticalSize
-            ? resolveRadius(toCSSPrimitiveValue(*m_endVerticalSize), conversionData, &height)
+            ? resolveRadius(toCSSPrimitiveValue(m_endVerticalSize), conversionData, &height)
             : secondRadius.width());
     } else {
-        EndShapeType shape = (m_shape && toCSSPrimitiveValue(*m_shape).getValueID() == CSSValueCircle)
+        EndShapeType shape = (m_shape && toCSSPrimitiveValue(m_shape).getValueID() == CSSValueCircle)
             || (!m_shape && !m_sizingBehavior && m_endHorizontalSize && !m_endVerticalSize)
             ? CircleEndShape
             : EllipseEndShape;
 
-        switch (m_sizingBehavior ? toCSSPrimitiveValue(*m_sizingBehavior).getValueID() : 0) {
+        switch (m_sizingBehavior ? toCSSPrimitiveValue(m_sizingBehavior).getValueID() : 0) {
         case CSSValueContain:
         case CSSValueClosestSide:
             secondRadius = radiusToSide(secondPoint, size, shape,
                 [] (float a, float b) { return a < b; });
             break;
         case CSSValueFarthestSide:
             secondRadius = radiusToSide(secondPoint, size, shape,
                 [] (float a, float b) { return a > b; });
             break;
         case CSSValueClosestCorner:
@@ skipping 71 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