Made all const methods on CSSPrimitiveValue have the const keyword

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 449 matching lines @@
     case UnitType::PropertyID:
     case UnitType::ValueID:
         break;
     }
     if (m_hasCachedCSSText) {
         cssTextCache().remove(this);
         m_hasCachedCSSText = false;
     }
 }
 
-double CSSPrimitiveValue::computeSeconds()
+double CSSPrimitiveValue::computeSeconds() const
 {
     ASSERT(isTime() || (isCalculated() && cssCalcValue()->category() == CalcTime));
     UnitType currentType = isCalculated() ? cssCalcValue()->expressionNode()->typeWithCalcResolved() : type();
     if (currentType == UnitType::Seconds)
         return getDoubleValue();
     if (currentType == UnitType::Milliseconds)
         return getDoubleValue() / 1000;
     ASSERT_NOT_REACHED();
     return 0;
 }
@@ skipping 10 matching lines @@
     case UnitType::Gradians:
         return grad2deg(getDoubleValue());
     case UnitType::Turns:
         return turn2deg(getDoubleValue());
     default:
         ASSERT_NOT_REACHED();
         return 0;
     }
 }
 
-template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<int>(computeLengthDouble(conversionData));
 }
 
-template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<unsigned>(computeLengthDouble(conversionData));
 }
 
-template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return Length(clampToCSSLengthRange(computeLengthDouble(conversionData)), Fixed);
 }
 
-template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<short>(computeLengthDouble(conversionData));
 }
 
-template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<unsigned short>(computeLengthDouble(conversionData));
 }
 
-template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return static_cast<float>(computeLengthDouble(conversionData));
 }
 
-template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return computeLengthDouble(conversionData);
 }
 
-double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData)
+double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData) const
 {
     // The logic in this function is duplicated in MediaValues::computeLength
     // because MediaValues::computeLength needs nearly identical logic, but we haven't found a way to make
     // CSSPrimitiveValue::computeLengthDouble more generic (to solve both cases) without hurting performance.
     if (type() == UnitType::Calc)
         return m_value.calc->computeLengthPx(conversionData);
 
     double factor;
 
     switch (type()) {
@@ skipping 128 matching lines @@
     case UnitType::Kilohertz:
         factor = 1000;
         break;
     default:
         break;
     }
 
     return factor;
 }
 
-Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData)
+Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) const
 {
     if (isLength())
         return computeLength<Length>(conversionData);
     if (isPercentage())
         return Length(getDoubleValue(), Percent);
     ASSERT(isCalculated());
     return Length(cssCalcValue()->toCalcValue(conversionData));
 }
 
 double CSSPrimitiveValue::getDoubleValue() const
@@ skipping 413 matching lines @@
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink