[SVG2] Add support for the 'turn' unit in <angle>.

Source/core/svg/SVGAngle.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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.
  *
@@ skipping 99 matching lines @@
     return point.release();
 }
 
 float SVGAngle::value() const
 {
     switch (m_unitType) {
     case SVG_ANGLETYPE_GRAD:
         return grad2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_RAD:
         return rad2deg(m_valueInSpecifiedUnits);
+    case SVG_ANGLETYPE_TURN:
+        return turn2deg(m_valueInSpecifiedUnits);
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
     case SVG_ANGLETYPE_DEG:
         return m_valueInSpecifiedUnits;
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 void SVGAngle::setValue(float value)
 {
     switch (m_unitType) {
     case SVG_ANGLETYPE_GRAD:
         m_valueInSpecifiedUnits = deg2grad(value);
         break;
     case SVG_ANGLETYPE_RAD:
         m_valueInSpecifiedUnits = deg2rad(value);
         break;
+    case SVG_ANGLETYPE_TURN:
+        m_valueInSpecifiedUnits = deg2turn(value);
+        break;
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
     case SVG_ANGLETYPE_DEG:
         m_valueInSpecifiedUnits = value;
         break;
     }
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
 }
 
 template<typename CharType>
@@ skipping 12 matching lines @@
         const CharType secondChar = *ptr++;
         const CharType thirdChar = *ptr++;
         if (firstChar == 'd' && secondChar == 'e' && thirdChar == 'g') {
             type = SVGAngle::SVG_ANGLETYPE_DEG;
         } else if (firstChar == 'r' && secondChar == 'a' && thirdChar == 'd') {
             type = SVGAngle::SVG_ANGLETYPE_RAD;
         } else if (ptr != end) {
             const CharType fourthChar = *ptr++;
             if (firstChar == 'g' && secondChar == 'r' && thirdChar == 'a' && fourthChar == 'd')
                 type = SVGAngle::SVG_ANGLETYPE_GRAD;
+            else if (firstChar == 't' && secondChar == 'u' && thirdChar == 'r' && fourthChar == 'n')
+                type = SVGAngle::SVG_ANGLETYPE_TURN;
         }
     }
 
     if (!skipOptionalSVGSpaces(ptr, end))
         return type;
 
     return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
 }
 
 String SVGAngle::valueAsString() const
 {
     switch (m_unitType) {
     case SVG_ANGLETYPE_DEG: {
         DEFINE_STATIC_LOCAL(String, degString, ("deg"));
         return String::number(m_valueInSpecifiedUnits) + degString;
     }
     case SVG_ANGLETYPE_RAD: {
         DEFINE_STATIC_LOCAL(String, radString, ("rad"));
         return String::number(m_valueInSpecifiedUnits) + radString;
     }
     case SVG_ANGLETYPE_GRAD: {
         DEFINE_STATIC_LOCAL(String, gradString, ("grad"));
         return String::number(m_valueInSpecifiedUnits) + gradString;
     }
+    case SVG_ANGLETYPE_TURN: {
+        DEFINE_STATIC_LOCAL(String, turnString, ("turn"));
+        return String::number(m_valueInSpecifiedUnits) + turnString;
+    }
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
         return String::number(m_valueInSpecifiedUnits);
     }
 
     ASSERT_NOT_REACHED();
     return String();
 }
 
 template<typename CharType>
@@ skipping 51 matching lines @@
 {
     if (m_unitType == SVG_ANGLETYPE_UNKNOWN) {
         exceptionState.throwDOMException(NotSupportedError, "Cannot convert from unknown or invalid units.");
         return;
     }
 
     if (unitType == m_unitType)
         return;
 
     switch (m_unitType) {
+    case SVG_ANGLETYPE_TURN:
+        switch (unitType) {
+        case SVG_ANGLETYPE_GRAD:
+            m_valueInSpecifiedUnits = turn2grad(m_valueInSpecifiedUnits);
+            break;
+        case SVG_ANGLETYPE_UNSPECIFIED:
+        case SVG_ANGLETYPE_DEG:
+            m_valueInSpecifiedUnits = turn2deg(m_valueInSpecifiedUnits);
+            break;
+        case SVG_ANGLETYPE_RAD:
+            m_valueInSpecifiedUnits = deg2rad(turn2deg(m_valueInSpecifiedUnits));
+            break;
+        case SVG_ANGLETYPE_TURN:
+        case SVG_ANGLETYPE_UNKNOWN:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        break;
     case SVG_ANGLETYPE_RAD:
         switch (unitType) {
         case SVG_ANGLETYPE_GRAD:
             m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits);
             break;
         case SVG_ANGLETYPE_UNSPECIFIED:
         case SVG_ANGLETYPE_DEG:
             m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits);
             break;
+        case SVG_ANGLETYPE_TURN:
+            m_valueInSpecifiedUnits = deg2turn(rad2deg(m_valueInSpecifiedUnits));
+            break;
         case SVG_ANGLETYPE_RAD:
         case SVG_ANGLETYPE_UNKNOWN:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
     case SVG_ANGLETYPE_GRAD:
         switch (unitType) {
         case SVG_ANGLETYPE_RAD:
             m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits);
             break;
         case SVG_ANGLETYPE_UNSPECIFIED:
         case SVG_ANGLETYPE_DEG:
             m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits);
             break;
+        case SVG_ANGLETYPE_TURN:
+            m_valueInSpecifiedUnits = grad2turn(m_valueInSpecifiedUnits);
+            break;
         case SVG_ANGLETYPE_GRAD:
         case SVG_ANGLETYPE_UNKNOWN:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
     case SVG_ANGLETYPE_UNSPECIFIED:
         // Spec: For angles, a unitless value is treated the same as if degrees were specified.
     case SVG_ANGLETYPE_DEG:
         switch (unitType) {
         case SVG_ANGLETYPE_RAD:
             m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits);
             break;
         case SVG_ANGLETYPE_GRAD:
             m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits);
             break;
+        case SVG_ANGLETYPE_TURN:
+            m_valueInSpecifiedUnits = deg2turn(m_valueInSpecifiedUnits);
+            break;
         case SVG_ANGLETYPE_UNSPECIFIED:
+        case SVG_ANGLETYPE_DEG:
             break;
-        case SVG_ANGLETYPE_DEG:
         case SVG_ANGLETYPE_UNKNOWN:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
     case SVG_ANGLETYPE_UNKNOWN:
         ASSERT_NOT_REACHED();
         break;
     }
 
@@ skipping 70 matching lines @@
 
 void SVGAngle::orientTypeChanged()
 {
     if (orientType()->enumValue() == SVGMarkerOrientAuto) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 }