Extended error reporting for SVG attribute parsing

third_party/WebKit/Source/core/svg/SVGPreserveAspectRatio.cpp

 /*
  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2010 Dirk Schulze <krit@webkit.org>
  *
  * 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 34 matching lines @@
 {
     RefPtrWillBeRawPtr<SVGPreserveAspectRatio> preserveAspectRatio = create();
 
     preserveAspectRatio->m_align = m_align;
     preserveAspectRatio->m_meetOrSlice = m_meetOrSlice;
 
     return preserveAspectRatio.release();
 }
 
 template<typename CharType>
-bool SVGPreserveAspectRatio::parseInternal(const CharType*& ptr, const CharType* end, bool validate)
+SVGParsingError SVGPreserveAspectRatio::parseInternal(const CharType*& ptr, const CharType* end, bool validate)
 {
     SVGPreserveAspectRatioType align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
     SVGMeetOrSliceType meetOrSlice = SVG_MEETORSLICE_MEET;
 
     setAlign(align);
     setMeetOrSlice(meetOrSlice);
 
+    const CharType* start = ptr;
     if (!skipOptionalSVGSpaces(ptr, end))
-        return false;
+        return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
 
     if (*ptr == 'n') {
         if (!skipString(ptr, end, "none"))
-            return false;
+            return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
         align = SVG_PRESERVEASPECTRATIO_NONE;
         skipOptionalSVGSpaces(ptr, end);
     } else if (*ptr == 'x') {
         if ((end - ptr) < 8)
-            return false;
+            return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
         if (ptr[1] != 'M' || ptr[4] != 'Y' || ptr[5] != 'M')
-            return false;
+            return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
         if (ptr[2] == 'i') {
             if (ptr[3] == 'n') {
                 if (ptr[6] == 'i') {
                     if (ptr[7] == 'n')
                         align = SVG_PRESERVEASPECTRATIO_XMINYMIN;
                     else if (ptr[7] == 'd')
                         align = SVG_PRESERVEASPECTRATIO_XMINYMID;
                     else
-                        return false;
+                        return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
                 } else if (ptr[6] == 'a' && ptr[7] == 'x') {
                     align = SVG_PRESERVEASPECTRATIO_XMINYMAX;
                 } else {
-                    return false;
+                    return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
                 }
             } else if (ptr[3] == 'd') {
                 if (ptr[6] == 'i') {
                     if (ptr[7] == 'n')
                         align = SVG_PRESERVEASPECTRATIO_XMIDYMIN;
                     else if (ptr[7] == 'd')
                         align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
                     else
-                        return false;
+                        return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
                 } else if (ptr[6] == 'a' && ptr[7] == 'x') {
                     align = SVG_PRESERVEASPECTRATIO_XMIDYMAX;
                 } else {
-                    return false;
+                    return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
                 }
             } else {
-                return false;
+                return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
             }
         } else if (ptr[2] == 'a' && ptr[3] == 'x') {
             if (ptr[6] == 'i') {
                 if (ptr[7] == 'n')
                     align = SVG_PRESERVEASPECTRATIO_XMAXYMIN;
                 else if (ptr[7] == 'd')
                     align = SVG_PRESERVEASPECTRATIO_XMAXYMID;
                 else
-                    return false;
+                    return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
             } else if (ptr[6] == 'a' && ptr[7] == 'x') {
                 align = SVG_PRESERVEASPECTRATIO_XMAXYMAX;
             } else {
-                return false;
+                return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
             }
         } else {
-            return false;
+            return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
         }
         ptr += 8;
         skipOptionalSVGSpaces(ptr, end);
     } else {
-        return false;
+        return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
     }
 
     if (ptr < end) {
         if (*ptr == 'm') {
             if (!skipString(ptr, end, "meet"))
-                return false;
+                return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
             skipOptionalSVGSpaces(ptr, end);
         } else if (*ptr == 's') {
             if (!skipString(ptr, end, "slice"))
-                return false;
+                return SVGParsingError(SVGParseStatus::ExpectedEnumeration, ptr - start);
             skipOptionalSVGSpaces(ptr, end);
             if (align != SVG_PRESERVEASPECTRATIO_NONE)
                 meetOrSlice = SVG_MEETORSLICE_SLICE;
         }
     }
 
     if (end != ptr && validate)
-        return false;
+        return SVGParsingError(SVGParseStatus::TrailingGarbage, ptr - start);
 
     setAlign(align);
     setMeetOrSlice(meetOrSlice);
 
-    return true;
+    return SVGParseStatus::NoError;
 }
 
 SVGParsingError SVGPreserveAspectRatio::setValueAsString(const String& string)
 {
     setDefault();
 
     if (string.isEmpty())
-        return NoError;
+        return SVGParseStatus::NoError;
 
-    bool valid = false;
     if (string.is8Bit()) {
         const LChar* ptr = string.characters8();
         const LChar* end = ptr + string.length();
-        valid = parseInternal(ptr, end, true);
-    } else {
-        const UChar* ptr = string.characters16();
-        const UChar* end = ptr + string.length();
-        valid = parseInternal(ptr, end, true);
+        return parseInternal(ptr, end, true);
     }
-    return valid ? NoError : ParsingAttributeFailedError;
+    const UChar* ptr = string.characters16();
+    const UChar* end = ptr + string.length();
+    return parseInternal(ptr, end, true);
 }
 
 bool SVGPreserveAspectRatio::parse(const LChar*& ptr, const LChar* end, bool validate)
 {
-    return parseInternal(ptr, end, validate);
+    return parseInternal(ptr, end, validate) == SVGParseStatus::NoError;
 }
 
 bool SVGPreserveAspectRatio::parse(const UChar*& ptr, const UChar* end, bool validate)
 {
-    return parseInternal(ptr, end, validate);
+    return parseInternal(ptr, end, validate) == SVGParseStatus::NoError;
 }
 
 void SVGPreserveAspectRatio::transformRect(FloatRect& destRect, FloatRect& srcRect)
 {
     if (m_align == SVG_PRESERVEASPECTRATIO_NONE)
         return;
 
     FloatSize imageSize = srcRect.size();
     float origDestWidth = destRect.width();
     float origDestHeight = destRect.height();
@@ skipping 210 matching lines @@
     m_meetOrSlice = preserveAspectRatioToUse->m_meetOrSlice;
 }
 
 float SVGPreserveAspectRatio::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, SVGElement* contextElement)
 {
     // No paced animations for SVGPreserveAspectRatio.
     return -1;
 }
 
 }