Make SVGLength wrap a CSSPrimitiveValue.

third_party/WebKit/Source/core/animation/LengthSVGInterpolation.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/animation/LengthSVGInterpolation.h"
 
 #include "core/css/CSSHelper.h"
 #include "core/svg/SVGAnimatedLength.h"
 #include "core/svg/SVGAnimatedLengthList.h"
@@ skipping 42 matching lines @@
 
 enum LengthInterpolatedUnit {
     LengthInterpolatedNumber,
     LengthInterpolatedPercentage,
     LengthInterpolatedEMS,
     LengthInterpolatedEXS,
     LengthInterpolatedREMS,
     LengthInterpolatedCHS,
 };
 
-static const SVGLengthType unitTypes[] = { LengthTypeNumber, LengthTypePercentage, LengthTypeEMS, LengthTypeEXS, LengthTypeREMS, LengthTypeCHS };
+static const CSSPrimitiveValue::UnitType unitTypes[] = {
+    CSSPrimitiveValue::UnitType::Number,
+    CSSPrimitiveValue::UnitType::Percentage,
+    CSSPrimitiveValue::UnitType::Ems,
+    CSSPrimitiveValue::UnitType::Exs,
+    CSSPrimitiveValue::UnitType::Rems,
+    CSSPrimitiveValue::UnitType::Chs };

[fs, 2015/10/30 19:50:00]

Nit: }; on next line

 
 const size_t numLengthInterpolatedUnits = WTF_ARRAY_LENGTH(unitTypes);
 
-LengthInterpolatedUnit convertToInterpolatedUnit(SVGLengthType lengthType, double& value)
+LengthInterpolatedUnit convertToInterpolatedUnit(CSSPrimitiveValue::UnitType unitType, double& value)
 {
-    switch (lengthType) {
-    case LengthTypeUnknown:
+    switch (unitType) {
+    case CSSPrimitiveValue::UnitType::Unknown:
     default:
         ASSERT_NOT_REACHED();
-    case LengthTypePX:
-    case LengthTypeNumber:
+    case CSSPrimitiveValue::UnitType::Pixels:
+    case CSSPrimitiveValue::UnitType::Number:
         return LengthInterpolatedNumber;
-    case LengthTypePercentage:
+    case CSSPrimitiveValue::UnitType::Percentage:
         return LengthInterpolatedPercentage;
-    case LengthTypeEMS:
+    case CSSPrimitiveValue::UnitType::Ems:
         return LengthInterpolatedEMS;
-    case LengthTypeEXS:
+    case CSSPrimitiveValue::UnitType::Exs:
         return LengthInterpolatedEXS;
-    case LengthTypeCM:
+    case CSSPrimitiveValue::UnitType::Centimeters:
         value *= cssPixelsPerCentimeter;
         return LengthInterpolatedNumber;
-    case LengthTypeMM:
+    case CSSPrimitiveValue::UnitType::Millimeters:
         value *= cssPixelsPerMillimeter;
         return LengthInterpolatedNumber;
-    case LengthTypeIN:
+    case CSSPrimitiveValue::UnitType::Inches:
         value *= cssPixelsPerInch;
         return LengthInterpolatedNumber;
-    case LengthTypePT:
+    case CSSPrimitiveValue::UnitType::Points:
         value *= cssPixelsPerPoint;
         return LengthInterpolatedNumber;
-    case LengthTypePC:
+    case CSSPrimitiveValue::UnitType::Picas:
         value *= cssPixelsPerPica;
         return LengthInterpolatedNumber;
-    case LengthTypeREMS:
+    case CSSPrimitiveValue::UnitType::UserUnits:
+        return LengthInterpolatedNumber;
+    case CSSPrimitiveValue::UnitType::Rems:
         return LengthInterpolatedREMS;
-    case LengthTypeCHS:
+    case CSSPrimitiveValue::UnitType::Chs:
         return LengthInterpolatedCHS;
     }
 }
 
 } // namespace
 
 PassOwnPtr<InterpolableValue> LengthSVGInterpolation::toInterpolableValue(SVGLength* length, const SVGAnimatedPropertyBase* attribute, NonInterpolableType* ptrModeData)
 {
     if (ptrModeData)
         populateModeData(attribute, ptrModeData);
 
     double value = length->valueInSpecifiedUnits();
-    LengthInterpolatedUnit unitType = convertToInterpolatedUnit(length->unitType(), value);
+    LengthInterpolatedUnit unitType = convertToInterpolatedUnit(length->typeWithCalcResolved(), value);
 
     double values[numLengthInterpolatedUnits] = { };
     values[unitType] = value;
 
     OwnPtr<InterpolableList> listOfValues = InterpolableList::create(numLengthInterpolatedUnits);
     for (size_t i = 0; i < numLengthInterpolatedUnits; ++i)
         listOfValues->set(i, InterpolableNumber::create(values[i]));
     return listOfValues.release();
 }
 
 PassRefPtrWillBeRawPtr<SVGLength> LengthSVGInterpolation::fromInterpolableValue(const InterpolableValue& interpolableValue, const NonInterpolableType& modeData, const SVGElement* element)
 {
     const InterpolableList& listOfValues = toInterpolableList(interpolableValue);
     ASSERT(element);
 
     double value = 0;
-    SVGLengthType lengthType = LengthTypeNumber;
+    CSSPrimitiveValue::UnitType unitType = CSSPrimitiveValue::UnitType::Number;
     unsigned unitTypeCount = 0;
     // We optimise for the common case where only one unit type is involved.
     for (size_t i = 0; i < numLengthInterpolatedUnits; i++) {
         double entry = toInterpolableNumber(listOfValues.get(i))->value();
         if (!entry)
             continue;
         unitTypeCount++;
         if (unitTypeCount > 1)
             break;
 
         value = entry;
-        lengthType = unitTypes[i];
+        unitType = unitTypes[i];
     }
 
     if (unitTypeCount > 1) {
         value = 0;
-        lengthType = LengthTypeNumber;
+        unitType = CSSPrimitiveValue::UnitType::Number;
 
         // SVGLength does not support calc expressions, so we convert to canonical units.
         SVGLengthContext lengthContext(element);
         for (size_t i = 0; i < numLengthInterpolatedUnits; i++) {
             double entry = toInterpolableNumber(listOfValues.get(i))->value();
             if (entry)
                 value += lengthContext.convertValueToUserUnits(entry, modeData.unitMode, unitTypes[i]);
         }
     }
 
     if (modeData.negativeValuesMode == ForbidNegativeLengths && value < 0)
         value = 0;
 
     RefPtrWillBeRawPtr<SVGLength> result = SVGLength::create(modeData.unitMode); // defaults to the length 0
-    result->setUnitType(lengthType);
-    result->setValueInSpecifiedUnits(value);
+    result->newValueSpecifiedUnits(unitType, value);
     return result.release();
 }
 
 PassRefPtrWillBeRawPtr<SVGPropertyBase> LengthSVGInterpolation::interpolatedValue(SVGElement& targetElement) const
 {
     return fromInterpolableValue(*m_cachedValue, m_modeData, &targetElement);
 }
 
 }