Error reporting for SVGAngle

third_party/WebKit/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 145 matching lines @@
 }
 
 template<typename CharType>
 static SVGAngle::SVGAngleType stringToAngleType(const CharType*& ptr, const CharType* end)
 {
     // If there's no unit given, the angle type is unspecified.
     if (ptr == end)
         return SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
 
     SVGAngle::SVGAngleType type = SVGAngle::SVG_ANGLETYPE_UNKNOWN;
-    const CharType firstChar = *ptr++;
-
-    if (isHTMLSpace<CharType>(firstChar)) {
+    if (isHTMLSpace<CharType>(ptr[0])) {
         type = SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
-    } else if (end - ptr >= 2) {
-        const CharType secondChar = *ptr++;
-        const CharType thirdChar = *ptr++;
-        if (firstChar == 'd' && secondChar == 'e' && thirdChar == 'g') {
+        ptr++;
+    } else if (end - ptr >= 3) {
+        if (ptr[0] == 'd' && ptr[1] == 'e' && ptr[2] == 'g') {
             type = SVGAngle::SVG_ANGLETYPE_DEG;
-        } else if (firstChar == 'r' && secondChar == 'a' && thirdChar == 'd') {
+            ptr += 3;
+        } else if (ptr[0] == 'r' && ptr[1] == 'a' && ptr[2] == 'd') {
             type = SVGAngle::SVG_ANGLETYPE_RAD;
-        } else if (ptr != end) {
-            const CharType fourthChar = *ptr++;
-            if (firstChar == 'g' && secondChar == 'r' && thirdChar == 'a' && fourthChar == 'd')
+            ptr += 3;
+        } else if (end - ptr >= 4) {
+            if (ptr[0] == 'g' && ptr[1] == 'r' && ptr[2] == 'a' && ptr[3] == 'd') {
                 type = SVGAngle::SVG_ANGLETYPE_GRAD;
-            else if (firstChar == 't' && secondChar == 'u' && thirdChar == 'r' && fourthChar == 'n')
+                ptr += 4;
+            } else if (ptr[0] == 't' && ptr[1] == 'u' && ptr[2] == 'r' && ptr[3] == 'n') {
                 type = SVGAngle::SVG_ANGLETYPE_TURN;
+                ptr += 4;
+            }
         }
     }
 
     if (!skipOptionalSVGSpaces(ptr, end))
         return type;
 
     return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
 }
 
 String SVGAngle::valueAsString() const
@@ skipping 18 matching lines @@
     case SVG_ANGLETYPE_UNSPECIFIED:
     case SVG_ANGLETYPE_UNKNOWN:
         return String::number(m_valueInSpecifiedUnits);
     }
 
     ASSERT_NOT_REACHED();
     return String();
 }
 
 template<typename CharType>
-static bool parseValue(const String& value, float& valueInSpecifiedUnits, SVGAngle::SVGAngleType& unitType)
+static SVGParsingError parseValue(const String& value, float& valueInSpecifiedUnits, SVGAngle::SVGAngleType& unitType)
 {
     const CharType* ptr = value.getCharacters<CharType>();
     const CharType* end = ptr + value.length();
 
     if (!parseNumber(ptr, end, valueInSpecifiedUnits, AllowLeadingWhitespace))
-        return false;
+        return SVGParsingError(SVGParseStatus::ExpectedAngle, ptr - value.getCharacters<CharType>());
 
     unitType = stringToAngleType(ptr, end);
     if (unitType == SVGAngle::SVG_ANGLETYPE_UNKNOWN)
-        return false;
+        return SVGParsingError(SVGParseStatus::ExpectedAngle, ptr - value.getCharacters<CharType>());
 
-    return true;
+    return SVGParseStatus::NoError;
 }
 
 SVGParsingError SVGAngle::setValueAsString(const String& value)
 {
     if (value.isEmpty()) {
         newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
         return SVGParseStatus::NoError;
     }
 
     if (value == "auto") {
         newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
         m_orientType->setEnumValue(SVGMarkerOrientAuto);
         return SVGParseStatus::NoError;
     }
     if (value == "auto-start-reverse") {
         newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
         m_orientType->setEnumValue(SVGMarkerOrientAutoStartReverse);
         return SVGParseStatus::NoError;
     }
 
     float valueInSpecifiedUnits = 0;
     SVGAngleType unitType = SVG_ANGLETYPE_UNKNOWN;
 
-    bool success = value.is8Bit() ? parseValue<LChar>(value, valueInSpecifiedUnits, unitType)
-                                  : parseValue<UChar>(value, valueInSpecifiedUnits, unitType);
-    if (!success)
-        return SVGParseStatus::ParsingFailed;
+    SVGParsingError error;
+    if (value.is8Bit())
+        error = parseValue<LChar>(value, valueInSpecifiedUnits, unitType);
+    else
+        error = parseValue<UChar>(value, valueInSpecifiedUnits, unitType);
+    if (error != SVGParseStatus::NoError)
+        return error;
 
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
     m_unitType = unitType;
     m_valueInSpecifiedUnits = valueInSpecifiedUnits;
     return SVGParseStatus::NoError;
 }
 
 void SVGAngle::newValueSpecifiedUnits(SVGAngleType unitType, float valueInSpecifiedUnits)
 {
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
@@ skipping 161 matching lines @@
 
 void SVGAngle::orientTypeChanged()
 {
     if (orientType()->enumValue() == SVGMarkerOrientAuto || orientType()->enumValue() == SVGMarkerOrientAutoStartReverse) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 } // namespace blink