CSSValue Immediates: Add move operators to CSSPrimitiveValue

Source/core/css/resolver/TransformBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 25 matching lines @@
 #include "platform/transforms/MatrixTransformOperation.h"
 #include "platform/transforms/PerspectiveTransformOperation.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/SkewTransformOperation.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 
 namespace blink {
 
-static Length convertToFloatLength(CSSPrimitiveValue& primitiveValue, const CSSToLengthConversionData& conversionData)
+static Length convertToFloatLength(CSSPrimitiveValue primitiveValue, const CSSToLengthConversionData& conversionData)
 {
     return primitiveValue.convertToLength(conversionData);
 }
 
 static TransformOperation::OperationType getTransformOperationType(CSSValueID type)
 {
     switch (type) {
     case CSSValueScale: return TransformOperation::Scale;
     case CSSValueScaleX: return TransformOperation::ScaleX;
     case CSSValueScaleY: return TransformOperation::ScaleY;
@@ skipping 28 matching lines @@
     if (!inValue.isValueList()) {
         ASSERT(inValue.isPrimitiveValue() && toCSSPrimitiveValue(inValue).getValueID() == CSSValueNone);
         return;
     }
 
     float zoomFactor = conversionData.zoom();
     for (auto& value : toCSSValueList(inValue)) {
         CSSFunctionValue& transformValue = toCSSFunctionValue(value);
         TransformOperation::OperationType transformType = getTransformOperationType(transformValue.functionType());
 
-        CSSPrimitiveValue& firstValue = toCSSPrimitiveValue(transformValue.item(0));
+        const CSSPrimitiveValue& firstValue = toCSSPrimitiveValue(transformValue.item(0));
 
         switch (transformType) {
         case TransformOperation::Scale:
         case TransformOperation::ScaleX:
         case TransformOperation::ScaleY: {
             double sx = 1.0;
             double sy = 1.0;
             if (transformType == TransformOperation::ScaleY) {
                 sy = firstValue.getDoubleValue();
             } else {
                 sx = firstValue.getDoubleValue();
                 if (transformType != TransformOperation::ScaleX) {
                     if (transformValue.length() > 1) {
-                        CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
+                        const CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
                         sy = secondValue.getDoubleValue();
                     } else {
                         sy = sx;
                     }
                 }
             }
             outOperations.operations().append(ScaleTransformOperation::create(sx, sy, 1.0, transformType));
             break;
         }
         case TransformOperation::ScaleZ:
@@ skipping 15 matching lines @@
         case TransformOperation::TranslateX:
         case TransformOperation::TranslateY: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             if (transformType == TransformOperation::TranslateY)
                 ty = convertToFloatLength(firstValue, conversionData);
             else {
                 tx = convertToFloatLength(firstValue, conversionData);
                 if (transformType != TransformOperation::TranslateX) {
                     if (transformValue.length() > 1) {
-                        CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
+                        const CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
                         ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
             outOperations.operations().append(TranslateTransformOperation::create(tx, ty, 0, transformType));
             break;
         }
         case TransformOperation::TranslateZ:
         case TransformOperation::Translate3D: {
@@ skipping 15 matching lines @@
         case TransformOperation::RotateY:
         case TransformOperation::RotateZ: {
             double angle = firstValue.computeDegrees();
             double x = transformType == TransformOperation::RotateX;
             double y = transformType == TransformOperation::RotateY;
             double z = transformType == TransformOperation::RotateZ;
             outOperations.operations().append(RotateTransformOperation::create(x, y, z, angle, transformType));
             break;
         }
         case TransformOperation::Rotate3D: {
-            CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
-            CSSPrimitiveValue& thirdValue = toCSSPrimitiveValue(transformValue.item(2));
-            CSSPrimitiveValue& fourthValue = toCSSPrimitiveValue(transformValue.item(3));
+            const CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
+            const CSSPrimitiveValue& thirdValue = toCSSPrimitiveValue(transformValue.item(2));
+            const CSSPrimitiveValue& fourthValue = toCSSPrimitiveValue(transformValue.item(3));
             double x = firstValue.getDoubleValue();
             double y = secondValue.getDoubleValue();
             double z = thirdValue.getDoubleValue();
             double angle = fourthValue.computeDegrees();
             outOperations.operations().append(RotateTransformOperation::create(x, y, z, angle, transformType));
             break;
         }
         case TransformOperation::Skew:
         case TransformOperation::SkewX:
         case TransformOperation::SkewY: {
             double angleX = 0;
             double angleY = 0;
             double angle = firstValue.computeDegrees();
             if (transformType == TransformOperation::SkewY)
                 angleY = angle;
             else {
                 angleX = angle;
                 if (transformType == TransformOperation::Skew) {
                     if (transformValue.length() > 1) {
-                        CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
+                        const CSSPrimitiveValue& secondValue = toCSSPrimitiveValue(transformValue.item(1));
                         angleY = secondValue.computeDegrees();
                     }
                 }
             }
             outOperations.operations().append(SkewTransformOperation::create(angleX, angleY, transformType));
             break;
         }
         case TransformOperation::Matrix: {
             double a = firstValue.getDoubleValue();
             double b = toCSSPrimitiveValue(transformValue.item(1)).getDoubleValue();
@@ skipping 31 matching lines @@
             break;
         }
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 }
 
 } // namespace blink