Reorder the emittal parts of SVGPathParser::parse*

Source/core/svg/SVGPathParser.cpp

 /*
  * Copyright (C) 2002, 2003 The Karbon Developers
  * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * 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
@@ skipping 35 matching lines @@
     m_closePath = true;
     m_consumer->closePath();
 }
 
 bool SVGPathParser::parseMoveToSegment()
 {
     FloatPoint targetPoint;
     if (!m_source->parseMoveToSegment(targetPoint))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        if (m_mode == RelativeCoordinates)
-            m_currentPoint += targetPoint;
-        else
-            m_currentPoint = targetPoint;
-        m_subPathPoint = m_currentPoint;
-        m_consumer->moveTo(m_currentPoint, m_closePath, AbsoluteCoordinates);
-    } else
+    if (m_pathParsingMode == UnalteredParsing) {
         m_consumer->moveTo(targetPoint, m_closePath, m_mode);
+        m_closePath = false;
+        return true;
+    }
+    if (m_mode == RelativeCoordinates)
+        m_currentPoint += targetPoint;
+    else
+        m_currentPoint = targetPoint;
+    m_subPathPoint = m_currentPoint;
+    m_consumer->moveTo(m_currentPoint, m_closePath, AbsoluteCoordinates);
     m_closePath = false;
     return true;
 }
 
 bool SVGPathParser::parseLineToSegment()
 {
     FloatPoint targetPoint;
     if (!m_source->parseLineToSegment(targetPoint))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        if (m_mode == RelativeCoordinates)
-            m_currentPoint += targetPoint;
-        else
-            m_currentPoint = targetPoint;
-        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
-    } else
+    if (m_pathParsingMode == UnalteredParsing) {
         m_consumer->lineTo(targetPoint, m_mode);
+        return true;
+    }
+    if (m_mode == RelativeCoordinates)
+        m_currentPoint += targetPoint;
+    else
+        m_currentPoint = targetPoint;
+    m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
     return true;
 }
 
 bool SVGPathParser::parseLineToHorizontalSegment()
 {
     float toX;
     if (!m_source->parseLineToHorizontalSegment(toX))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        if (m_mode == RelativeCoordinates)
-            m_currentPoint.move(toX, 0);
-        else
-            m_currentPoint.setX(toX);
-        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
-    } else
+    if (m_pathParsingMode == UnalteredParsing) {
         m_consumer->lineToHorizontal(toX, m_mode);
+        return true;
+    }
+    if (m_mode == RelativeCoordinates)
+        m_currentPoint.move(toX, 0);
+    else
+        m_currentPoint.setX(toX);
+    m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
     return true;
 }
 
 bool SVGPathParser::parseLineToVerticalSegment()
 {
     float toY;
     if (!m_source->parseLineToVerticalSegment(toY))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        if (m_mode == RelativeCoordinates)
-            m_currentPoint.move(0, toY);
-        else
-            m_currentPoint.setY(toY);
-        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
-    } else
+    if (m_pathParsingMode == UnalteredParsing) {
         m_consumer->lineToVertical(toY, m_mode);
+        return true;
+    }
+    if (m_mode == RelativeCoordinates)
+        m_currentPoint.move(0, toY);
+    else
+        m_currentPoint.setY(toY);
+    m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
     return true;
 }
 
 bool SVGPathParser::parseCurveToCubicSegment()
 {
     FloatPoint point1;
     FloatPoint point2;
     FloatPoint targetPoint;
     if (!m_source->parseCurveToCubicSegment(point1, point2, targetPoint))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        if (m_mode == RelativeCoordinates) {
-            point1 += m_currentPoint;
-            point2 += m_currentPoint;
-            targetPoint += m_currentPoint;
-        }
-        m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
+    if (m_pathParsingMode == UnalteredParsing) {
+        m_consumer->curveToCubic(point1, point2, targetPoint, m_mode);
+        return true;
+    }
+    if (m_mode == RelativeCoordinates) {
+        point1 += m_currentPoint;
+        point2 += m_currentPoint;
+        targetPoint += m_currentPoint;
+    }
+    m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-        m_controlPoint = point2;
-        m_currentPoint = targetPoint;
-    } else
-        m_consumer->curveToCubic(point1, point2, targetPoint, m_mode);
+    m_controlPoint = point2;
+    m_currentPoint = targetPoint;
     return true;
 }
 
 bool SVGPathParser::parseCurveToCubicSmoothSegment()
 {
     FloatPoint point2;
     FloatPoint targetPoint;
     if (!m_source->parseCurveToCubicSmoothSegment(point2, targetPoint))
         return false;
 
     if (m_lastCommand != PathSegCurveToCubicAbs
         && m_lastCommand != PathSegCurveToCubicRel
         && m_lastCommand != PathSegCurveToCubicSmoothAbs
         && m_lastCommand != PathSegCurveToCubicSmoothRel)
         m_controlPoint = m_currentPoint;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        FloatPoint point1 = m_currentPoint;
-        point1.scale(2, 2);
-        point1.move(-m_controlPoint.x(), -m_controlPoint.y());
-        if (m_mode == RelativeCoordinates) {
-            point2 += m_currentPoint;
-            targetPoint += m_currentPoint;
-        }
+    if (m_pathParsingMode == UnalteredParsing) {
+        m_consumer->curveToCubicSmooth(point2, targetPoint, m_mode);
+        return true;
+    }
+    FloatPoint point1 = m_currentPoint;
+    point1.scale(2, 2);
+    point1.move(-m_controlPoint.x(), -m_controlPoint.y());
+    if (m_mode == RelativeCoordinates) {
+        point2 += m_currentPoint;
+        targetPoint += m_currentPoint;
+    }
 
-        m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
+    m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-        m_controlPoint = point2;
-        m_currentPoint = targetPoint;
-    } else
-        m_consumer->curveToCubicSmooth(point2, targetPoint, m_mode);
+    m_controlPoint = point2;
+    m_currentPoint = targetPoint;
     return true;
 }
 
 bool SVGPathParser::parseCurveToQuadraticSegment()
 {
     FloatPoint point1;
     FloatPoint targetPoint;
     if (!m_source->parseCurveToQuadraticSegment(point1, targetPoint))
         return false;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        m_controlPoint = point1;
-        FloatPoint point1 = m_currentPoint;
-        point1.move(2 * m_controlPoint.x(), 2 * m_controlPoint.y());
-        FloatPoint point2(targetPoint.x() + 2 * m_controlPoint.x(), targetPoint.y() + 2 * m_controlPoint.y());
-        if (m_mode == RelativeCoordinates) {
-            point1.move(2 * m_currentPoint.x(), 2 * m_currentPoint.y());
-            point2.move(3 * m_currentPoint.x(), 3 * m_currentPoint.y());
-            targetPoint += m_currentPoint;
-        }
-        point1.scale(gOneOverThree, gOneOverThree);
-        point2.scale(gOneOverThree, gOneOverThree);
+    if (m_pathParsingMode == UnalteredParsing) {
+        m_consumer->curveToQuadratic(point1, targetPoint, m_mode);
+        return true;
+    }
+    m_controlPoint = point1;
+    point1 = m_currentPoint;
+    point1.move(2 * m_controlPoint.x(), 2 * m_controlPoint.y());
+    FloatPoint point2(targetPoint.x() + 2 * m_controlPoint.x(), targetPoint.y() + 2 * m_controlPoint.y());
+    if (m_mode == RelativeCoordinates) {
+        point1.move(2 * m_currentPoint.x(), 2 * m_currentPoint.y());
+        point2.move(3 * m_currentPoint.x(), 3 * m_currentPoint.y());
+        targetPoint += m_currentPoint;
+    }
+    point1.scale(gOneOverThree, gOneOverThree);
+    point2.scale(gOneOverThree, gOneOverThree);
 
-        m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
+    m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-        if (m_mode == RelativeCoordinates)
-            m_controlPoint += m_currentPoint;
-        m_currentPoint = targetPoint;
-    } else
-        m_consumer->curveToQuadratic(point1, targetPoint, m_mode);
+    if (m_mode == RelativeCoordinates)
+        m_controlPoint += m_currentPoint;
+    m_currentPoint = targetPoint;
     return true;
 }
 
 bool SVGPathParser::parseCurveToQuadraticSmoothSegment()
 {
     FloatPoint targetPoint;
     if (!m_source->parseCurveToQuadraticSmoothSegment(targetPoint))
         return false;
 
     if (m_lastCommand != PathSegCurveToQuadraticAbs
         && m_lastCommand != PathSegCurveToQuadraticRel
         && m_lastCommand != PathSegCurveToQuadraticSmoothAbs
         && m_lastCommand != PathSegCurveToQuadraticSmoothRel)
         m_controlPoint = m_currentPoint;
 
-    if (m_pathParsingMode == NormalizedParsing) {
-        FloatPoint cubicPoint = m_currentPoint;
-        cubicPoint.scale(2, 2);
-        cubicPoint.move(-m_controlPoint.x(), -m_controlPoint.y());
-        FloatPoint point1(m_currentPoint.x() + 2 * cubicPoint.x(), m_currentPoint.y() + 2 * cubicPoint.y());
-        FloatPoint point2(targetPoint.x() + 2 * cubicPoint.x(), targetPoint.y() + 2 * cubicPoint.y());
-        if (m_mode == RelativeCoordinates) {
-            point2 += m_currentPoint;
-            targetPoint += m_currentPoint;
-        }
-        point1.scale(gOneOverThree, gOneOverThree);
-        point2.scale(gOneOverThree, gOneOverThree);
+    if (m_pathParsingMode == UnalteredParsing) {
+        m_consumer->curveToQuadraticSmooth(targetPoint, m_mode);
+        return true;
+    }
+    FloatPoint cubicPoint = m_currentPoint;
+    cubicPoint.scale(2, 2);
+    cubicPoint.move(-m_controlPoint.x(), -m_controlPoint.y());
+    FloatPoint point1(m_currentPoint.x() + 2 * cubicPoint.x(), m_currentPoint.y() + 2 * cubicPoint.y());
+    FloatPoint point2(targetPoint.x() + 2 * cubicPoint.x(), targetPoint.y() + 2 * cubicPoint.y());
+    if (m_mode == RelativeCoordinates) {
+        point2 += m_currentPoint;
+        targetPoint += m_currentPoint;
+    }
+    point1.scale(gOneOverThree, gOneOverThree);
+    point2.scale(gOneOverThree, gOneOverThree);
 
-        m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
+    m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-        m_controlPoint = cubicPoint;
-        m_currentPoint = targetPoint;
-    } else
-        m_consumer->curveToQuadraticSmooth(targetPoint, m_mode);
+    m_controlPoint = cubicPoint;
+    m_currentPoint = targetPoint;
     return true;
 }
 
 bool SVGPathParser::parseArcToSegment()
 {
     float rx;
     float ry;
     float angle;
     bool largeArc;
     bool sweep;
@@ skipping 228 matching lines @@
         point2 = targetPoint;
         point2.move(t * sinEndTheta, -t * cosEndTheta);
 
         m_consumer->curveToCubic(pointTransform.mapPoint(point1), pointTransform.mapPoint(point2),
                                  pointTransform.mapPoint(targetPoint), AbsoluteCoordinates);
     }
     return true;
 }
 
 }