Change first() and second() in CSSPairValue to return const references

Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 319 matching lines @@
     if (angle > 135.0f && angle <= 225.0f)
         return GO_180DEG;
     return GO_270DEG;
 }
 
 StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(StyleResolverState&, CSSValue* value)
 {
     StyleSelfAlignmentData alignmentData = ComputedStyle::initialSelfAlignment();
     if (value->isValuePair()) {
         const CSSValuePair* pair = toCSSValuePair(value);
-        if (toCSSPrimitiveValue(pair->first())->getValueID() == CSSValueLegacy) {
+        if (toCSSPrimitiveValue(pair->first()).getValueID() == CSSValueLegacy) {
             alignmentData.setPositionType(LegacyPosition);
-            alignmentData.setPosition(*toCSSPrimitiveValue(pair->second()));
+            alignmentData.setPosition(toCSSPrimitiveValue(pair->second()));
         } else {
-            alignmentData.setPosition(*toCSSPrimitiveValue(pair->first()));
-            alignmentData.setOverflow(*toCSSPrimitiveValue(pair->second()));
+            alignmentData.setPosition(toCSSPrimitiveValue(pair->first()));
+            alignmentData.setOverflow(toCSSPrimitiveValue(pair->second()));
         }
     } else {
         alignmentData.setPosition(*toCSSPrimitiveValue(value));
     }
     return alignmentData;
 }
 
 StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolverState&, CSSValue* value)
 {
     StyleContentAlignmentData alignmentData = ComputedStyle::initialContentAlignment();
@@ skipping 173 matching lines @@
     return toCSSPrimitiveValue(value)->convertToLength(state.cssToLengthConversionData());
 }
 
 UnzoomedLength StyleBuilderConverter::convertUnzoomedLength(const StyleResolverState& state, CSSValue* value)
 {
     return UnzoomedLength(toCSSPrimitiveValue(value)->convertToLength(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)));
 }
 
 Length StyleBuilderConverter::convertLengthOrAuto(const StyleResolverState& state, CSSValue* value)
 {
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getValueID() == CSSValueAuto)
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*value);
+    if (primitiveValue.getValueID() == CSSValueAuto)
         return Length(Auto);
-    return primitiveValue->convertToLength(state.cssToLengthConversionData());
+    return primitiveValue.convertToLength(state.cssToLengthConversionData());
 }
 
 Length StyleBuilderConverter::convertLengthSizing(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue->getValueID()) {
     case CSSValueInvalid:
         return convertLength(state, value);
     case CSSValueIntrinsic:
         return Length(Intrinsic);
@@ skipping 77 matching lines @@
     ASSERT(primitiveValue->isNumber() || primitiveValue->isPercentage());
     if (primitiveValue->isNumber())
         return primitiveValue->getFloatValue();
     return primitiveValue->getFloatValue() / 100.0f;
 }
 
 template <CSSValueID cssValueFor0, CSSValueID cssValueFor100>
 static Length convertPositionLength(StyleResolverState& state, CSSValue* value)
 {
     if (value->isValuePair()) {
-        const CSSValuePair* pair = toCSSValuePair(value);
-        Length length = StyleBuilderConverter::convertLength(state, pair->second());
-        if (toCSSPrimitiveValue(pair->first())->getValueID() == cssValueFor0)
+        CSSValuePair* pair = toCSSValuePair(value);
+        Length length = StyleBuilderConverter::convertLength(state, &pair->second());
+        if (toCSSPrimitiveValue(pair->first()).getValueID() == cssValueFor0)
             return length;
-        ASSERT(toCSSPrimitiveValue(pair->first())->getValueID() == cssValueFor100);
+        ASSERT(toCSSPrimitiveValue(pair->first()).getValueID() == cssValueFor100);
         return length.subtractFromOneHundredPercent();
     }
 
     return StyleBuilderConverter::convertLength(state, value);
 }
 
 LengthPoint StyleBuilderConverter::convertPosition(StyleResolverState& state, CSSValue* value)
 {
-    const CSSValuePair* pair = toCSSValuePair(value);
+    CSSValuePair* pair = toCSSValuePair(value);
     return LengthPoint(
-        convertPositionLength<CSSValueLeft, CSSValueRight>(state, pair->first()),
-        convertPositionLength<CSSValueTop, CSSValueBottom>(state, pair->second())
+        convertPositionLength<CSSValueLeft, CSSValueRight>(state, &pair->first()),
+        convertPositionLength<CSSValueTop, CSSValueBottom>(state, &pair->second())
     );
 }
 
 static float convertPerspectiveLength(StyleResolverState& state, CSSPrimitiveValue* primitiveValue)
 {
     return std::max(primitiveValue->computeLength<float>(state.cssToLengthConversionData()), 0.0f);
 }
 
 float StyleBuilderConverter::convertPerspective(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 79 matching lines @@
         }
         return quotes.release();
     }
     // FIXME: We should assert we're a primitive value with valueID = CSSValueNone
     return QuotesData::create();
 }
 
 LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, CSSValue* value)
 {
     const CSSValuePair* pair = toCSSValuePair(value);
-    Length radiusWidth = toCSSPrimitiveValue(pair->first())->convertToLength(state.cssToLengthConversionData());
-    Length radiusHeight = toCSSPrimitiveValue(pair->second())->convertToLength(state.cssToLengthConversionData());
+    Length radiusWidth = toCSSPrimitiveValue(pair->first()).convertToLength(state.cssToLengthConversionData());
+    Length radiusHeight = toCSSPrimitiveValue(pair->second()).convertToLength(state.cssToLengthConversionData());
     float width = radiusWidth.value();
     float height = radiusHeight.value();
     ASSERT(width >= 0 && height >= 0);
     if (width <= 0 || height <= 0)
         return LengthSize(Length(0, Fixed), Length(0, Fixed));
     return LengthSize(radiusWidth, radiusHeight);
 }
 
 PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 59 matching lines @@
 PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isValueList())
         return SVGComputedStyle::initialStrokeDashArray();
 
     CSSValueList* dashes = toCSSValueList(value);
 
     RefPtr<SVGDashArray> array = SVGDashArray::create();
     size_t length = dashes->length();
     for (size_t i = 0; i < length; ++i) {
-        CSSPrimitiveValue* dash = toCSSPrimitiveValue(dashes->item(i));
-        array->append(convertLength(state, dash));
+        array->append(convertLength(state, toCSSPrimitiveValue(dashes->item(i))));
     }
 
     return array.release();
 }
 
 StyleColor StyleBuilderConverter::convertStyleColor(StyleResolverState& state, CSSValue* value, bool forVisitedLink)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue->getValueID() == CSSValueCurrentcolor)
         return StyleColor::currentColor();
@@ skipping 107 matching lines @@
     return ScaleTransformOperation::create(sx, sy, sz, TransformOperation::Scale3D);
 }
 
 RespectImageOrientationEnum StyleBuilderConverter::convertImageOrientation(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     return primitiveValue->getValueID() == CSSValueFromImage ? RespectImageOrientation : DoNotRespectImageOrientation;
 }
 
 } // namespace blink