Refactor away SVGPathSource

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

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2013 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 24 matching lines @@
     if (m_is8BitSource) {
         m_current.m_character8 = string.characters8();
         m_end.m_character8 = m_current.m_character8 + string.length();
     } else {
         m_current.m_character16 = string.characters16();
         m_end.m_character16 = m_current.m_character16 + string.length();
     }
     eatWhitespace();
 }
 
-bool SVGPathStringSource::hasMoreData() const
-{
-    if (m_is8BitSource)
-        return m_current.m_character8 < m_end.m_character8;
-    return m_current.m_character16 < m_end.m_character16;
-}
-
 void SVGPathStringSource::eatWhitespace()
 {
     if (m_is8BitSource)
         skipOptionalSVGSpaces(m_current.m_character8, m_end.m_character8);
     else
         skipOptionalSVGSpaces(m_current.m_character16, m_end.m_character16);
 }
 
-static SVGPathSegType parseSVGSegmentTypeHelper(unsigned lookahead)
+static SVGPathSegType mapLetterToSegmentType(unsigned lookahead)
 {
     switch (lookahead) {
     case 'Z':
     case 'z':
         return PathSegClosePath;
     case 'M':
         return PathSegMoveToAbs;
     case 'm':
         return PathSegMoveToRel;
     case 'L':
@@ skipping 26 matching lines @@
         return PathSegCurveToCubicSmoothRel;
     case 'T':
         return PathSegCurveToQuadraticSmoothAbs;
     case 't':
         return PathSegCurveToQuadraticSmoothRel;
     default:
         return PathSegUnknown;
     }
 }
 
-static bool nextCommandHelper(unsigned lookahead, SVGPathSegType previousCommand, SVGPathSegType& nextCommand)
+static bool isNumberStart(unsigned lookahead)
 {
-    // Check for remaining coordinates in the current command.
-    if ((lookahead == '+' || lookahead == '-' || lookahead == '.' || (lookahead >= '0' && lookahead <= '9'))
-        && previousCommand != PathSegClosePath) {
-        if (previousCommand == PathSegMoveToAbs) {
-            nextCommand = PathSegLineToAbs;
-            return true;
-        }
-        if (previousCommand == PathSegMoveToRel) {
-            nextCommand = PathSegLineToRel;
-            return true;
-        }
-        nextCommand = previousCommand;
+    return (lookahead >= '0' && lookahead <= '9')
+        || lookahead == '+'
+        || lookahead == '-'
+        || lookahead == '.';
+}
+
+static bool maybeImplicitCommand(unsigned lookahead, SVGPathSegType previousCommand, SVGPathSegType& nextCommand)
+{
+    // Check if the current lookahead may start a number - in which case it
+    // could be the start of an implicit command. The 'close' command does not
+    // have any parameters though and hence can't have an implicit
+    // 'continuation'.
+    if (!isNumberStart(lookahead) || previousCommand == PathSegClosePath)
+        return false;
+    // Implicit continuations of moveto command translate to linetos.
+    if (previousCommand == PathSegMoveToAbs) {
+        nextCommand = PathSegLineToAbs;
         return true;
     }
-    return false;
+    if (previousCommand == PathSegMoveToRel) {
+        nextCommand = PathSegLineToRel;
+        return true;
+    }
+    nextCommand = previousCommand;
+    return true;
 }
 
 void SVGPathStringSource::setErrorMark(SVGParseStatus status)
 {
     if (m_error.status() != SVGParseStatus::NoError)
         return;
     size_t locus = m_is8BitSource
         ? m_current.m_character8 - m_string.characters8()
         : m_current.m_character16 - m_string.characters16();
     m_error = SVGParsingError(status, locus);
@@ skipping 18 matching lines @@
     bool error;
     if (m_is8BitSource)
         error = !parseArcFlag(m_current.m_character8, m_end.m_character8, flagValue);
     else
         error = !parseArcFlag(m_current.m_character16, m_end.m_character16, flagValue);
     if (UNLIKELY(error))
         setErrorMark(SVGParseStatus::ExpectedArcFlag);
     return flagValue;
 }
 
-SVGPathSegType SVGPathStringSource::peekSegmentType()
-{
-    ASSERT(hasMoreData());
-    // This won't work in all cases because of the state required to "detect" implicit commands.
-    unsigned lookahead = m_is8BitSource ? *m_current.m_character8 : *m_current.m_character16;
-    SVGPathSegType segmentType = parseSVGSegmentTypeHelper(lookahead);
-    // Here we assume that this is only called via SVGPathParser::initialCommandIsMoveTo.
-    // TODO(fs): It ought to be possible to refactor away this entirely, and
-    // just handle this in parseSegment (which we sort of do already...) The
-    // only user is the method mentioned above.
-    if (segmentType != PathSegMoveToAbs && segmentType != PathSegMoveToRel)
-        setErrorMark(SVGParseStatus::ExpectedMoveToCommand);
-    return segmentType;
-}
-
 PathSegmentData SVGPathStringSource::parseSegment()
 {
     ASSERT(hasMoreData());
     PathSegmentData segment;
     unsigned lookahead = m_is8BitSource ? *m_current.m_character8 : *m_current.m_character16;
-    SVGPathSegType command = parseSVGSegmentTypeHelper(lookahead);
-    if (command == PathSegUnknown) {
-        // Possibly an implicit command. Not allowed if this is the first command.
-        if (m_previousCommand == PathSegUnknown) {
+    SVGPathSegType command = mapLetterToSegmentType(lookahead);
+    if (UNLIKELY(m_previousCommand == PathSegUnknown)) {
+        // First command has to be a moveto.
+        if (command != PathSegMoveToRel && command != PathSegMoveToAbs) {
             setErrorMark(SVGParseStatus::ExpectedMoveToCommand);
             return segment;
         }
-        if (!nextCommandHelper(lookahead, m_previousCommand, command)) {
+        // Consume command letter.
+        if (m_is8BitSource)
+            m_current.m_character8++;
+        else
+            m_current.m_character16++;
+    } else if (command == PathSegUnknown) {
+        // Possibly an implicit command.
+        ASSERT(m_previousCommand != PathSegUnknown);
+        if (!maybeImplicitCommand(lookahead, m_previousCommand, command)) {
             setErrorMark(SVGParseStatus::ExpectedPathCommand);
             return segment;
         }
     } else {
         // Valid explicit command.
         if (m_is8BitSource)
             m_current.m_character8++;
         else
             m_current.m_character16++;
     }
@@ skipping 53 matching lines @@
     case PathSegUnknown:
         ASSERT_NOT_REACHED();
     }
 
     if (UNLIKELY(m_error.status() != SVGParseStatus::NoError))
         segment.command = PathSegUnknown;
     return segment;
 }
 
 } // namespace blink