SVGPathParser: Move unaltered emits to a separate code-path

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 31 matching lines @@
     if (!m_source->hasMoreData())
         return true;
 
     SVGPathSegType command = m_source->peekSegmentType();
     // Path must start with moveTo.
     return command == PathSegMoveToAbs || command == PathSegMoveToRel;
 }
 
 void SVGPathParser::emitMoveToSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->moveTo(segment.targetPoint, m_mode);
-        return;
-    }
     if (m_mode == RelativeCoordinates)
         m_currentPoint += segment.targetPoint;
     else
         m_currentPoint = segment.targetPoint;
     m_subPathPoint = m_currentPoint;
     m_consumer->moveTo(m_currentPoint, AbsoluteCoordinates);
 }
 
 void SVGPathParser::emitLineToSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->lineTo(segment.targetPoint, m_mode);
-        return;
-    }
     if (m_mode == RelativeCoordinates)
         m_currentPoint += segment.targetPoint;
     else
         m_currentPoint = segment.targetPoint;
     m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
 }
 
 void SVGPathParser::emitLineToHorizontalSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->lineToHorizontal(segment.targetPoint.x(), m_mode);
-        return;
-    }
     if (m_mode == RelativeCoordinates)
         m_currentPoint += segment.targetPoint;
     else
         m_currentPoint.setX(segment.targetPoint.x());
     m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
 }
 
 void SVGPathParser::emitLineToVerticalSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->lineToVertical(segment.targetPoint.y(), m_mode);
-        return;
-    }
     if (m_mode == RelativeCoordinates)
         m_currentPoint += segment.targetPoint;
     else
         m_currentPoint.setY(segment.targetPoint.y());
     m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);
 }
 
 void SVGPathParser::emitCurveToCubicSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->curveToCubic(segment.point1, segment.point2, segment.targetPoint, m_mode);
-        return;
-    }
     if (m_mode == RelativeCoordinates) {
         segment.point1 += m_currentPoint;
         segment.point2 += m_currentPoint;
         segment.targetPoint += m_currentPoint;
     }
     m_consumer->curveToCubic(segment.point1, segment.point2, segment.targetPoint, AbsoluteCoordinates);
 
     m_controlPoint = segment.point2;
     m_currentPoint = segment.targetPoint;
 }
 
 static FloatPoint reflectedPoint(const FloatPoint& reflectIn, const FloatPoint& pointToReflect)
 {
     return FloatPoint(2 * reflectIn.x() - pointToReflect.x(), 2 * reflectIn.y() - pointToReflect.y());
 }
 
 void SVGPathParser::emitCurveToCubicSmoothSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->curveToCubicSmooth(segment.point2, segment.targetPoint, m_mode);
-        return;
-    }
     if (m_lastCommand != PathSegCurveToCubicAbs
         && m_lastCommand != PathSegCurveToCubicRel
         && m_lastCommand != PathSegCurveToCubicSmoothAbs
         && m_lastCommand != PathSegCurveToCubicSmoothRel)
         m_controlPoint = m_currentPoint;
 
     FloatPoint point1 = reflectedPoint(m_currentPoint, m_controlPoint);
     if (m_mode == RelativeCoordinates) {
         segment.point2 += m_currentPoint;
         segment.targetPoint += m_currentPoint;
     }
 
     m_consumer->curveToCubic(point1, segment.point2, segment.targetPoint, AbsoluteCoordinates);
 
     m_controlPoint = segment.point2;
     m_currentPoint = segment.targetPoint;
 }
 
 // Blend the points with a ratio (1/3):(2/3).
 static FloatPoint blendPoints(const FloatPoint& p1, const FloatPoint& p2)
 {
     const float oneOverThree = 1 / 3.f;
     return FloatPoint((p1.x() + 2 * p2.x()) * oneOverThree, (p1.y() + 2 * p2.y()) * oneOverThree);
 }
 
 void SVGPathParser::emitCurveToQuadraticSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->curveToQuadratic(segment.point1, segment.targetPoint, m_mode);
-        return;
-    }
     m_controlPoint = segment.point1;
 
     if (m_mode == RelativeCoordinates) {
         m_controlPoint += m_currentPoint;
         segment.targetPoint += m_currentPoint;
     }
     segment.point1 = blendPoints(m_currentPoint, m_controlPoint);
     FloatPoint point2 = blendPoints(segment.targetPoint, m_controlPoint);
 
     m_consumer->curveToCubic(segment.point1, point2, segment.targetPoint, AbsoluteCoordinates);
 
     m_currentPoint = segment.targetPoint;
 }
 
 void SVGPathParser::emitCurveToQuadraticSmoothSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->curveToQuadraticSmooth(segment.targetPoint, m_mode);
-        return;
-    }
     if (m_lastCommand != PathSegCurveToQuadraticAbs
         && m_lastCommand != PathSegCurveToQuadraticRel
         && m_lastCommand != PathSegCurveToQuadraticSmoothAbs
         && m_lastCommand != PathSegCurveToQuadraticSmoothRel)
         m_controlPoint = m_currentPoint;
 
     if (m_mode == RelativeCoordinates)
         segment.targetPoint += m_currentPoint;
 
     m_controlPoint = reflectedPoint(m_currentPoint, m_controlPoint);
     FloatPoint point1 = blendPoints(m_currentPoint, m_controlPoint);
     FloatPoint point2 = blendPoints(segment.targetPoint, m_controlPoint);
 
     m_consumer->curveToCubic(point1, point2, segment.targetPoint, AbsoluteCoordinates);
 
     m_currentPoint = segment.targetPoint;
 }
 
 void SVGPathParser::emitArcToSegment(PathSegmentData& segment)
 {
-    if (m_pathParsingMode == UnalteredParsing) {
-        m_consumer->arcTo(segment.arcRadii().x(), segment.arcRadii().y(), segment.arcAngle(), segment.arcLarge, segment.arcSweep, segment.targetPoint, m_mode);
-        return;
-    }
-
     // If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.
     // http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
     // If the current point and target point for the arc are identical, it should be treated as a zero length
     // path. This ensures continuity in animations.
     float rx = fabsf(segment.arcRadii().x());
     float ry = fabsf(segment.arcRadii().y());
 
     if (m_mode == RelativeCoordinates)
         segment.targetPoint += m_currentPoint;
 
     if (!rx || !ry || segment.targetPoint == m_currentPoint) {
         m_consumer->lineTo(segment.targetPoint, AbsoluteCoordinates);
         m_currentPoint = segment.targetPoint;
         return;
     }
 
     float angle = segment.arcAngle();
     FloatPoint point1 = m_currentPoint;
     m_currentPoint = segment.targetPoint;
     if (!decomposeArcToCubic(angle, rx, ry, point1, segment.targetPoint, segment.arcLarge, segment.arcSweep))
         m_consumer->lineTo(segment.targetPoint, AbsoluteCoordinates);
 }
 
 bool SVGPathParser::parsePathDataFromSource(PathParsingMode pathParsingMode, bool checkForInitialMoveTo)
 {
     ASSERT(m_source);
     ASSERT(m_consumer);
 
-    m_pathParsingMode = pathParsingMode;
-
     m_controlPoint = FloatPoint();
     m_currentPoint = FloatPoint();
     m_subPathPoint = FloatPoint();
 
     if (checkForInitialMoveTo && !initialCommandIsMoveTo())
         return false;
 
     m_lastCommand = PathSegUnknown;
     while (m_source->hasMoreData()) {
         PathSegmentData segment = m_source->parseSegment();
         if (segment.command == PathSegUnknown)
             return false;
 
-        m_mode = AbsoluteCoordinates;
+        if (pathParsingMode == NormalizedParsing) {
+            m_mode = AbsoluteCoordinates;
 
-        switch (segment.command) {
-        case PathSegMoveToRel:
-            m_mode = RelativeCoordinates;
-        case PathSegMoveToAbs:
-            emitMoveToSegment(segment);
-            break;
-        case PathSegLineToRel:
-            m_mode = RelativeCoordinates;
-        case PathSegLineToAbs:
-            emitLineToSegment(segment);
-            break;
-        case PathSegLineToHorizontalRel:
-            m_mode = RelativeCoordinates;
-        case PathSegLineToHorizontalAbs:
-            emitLineToHorizontalSegment(segment);
-            break;
-        case PathSegLineToVerticalRel:
-            m_mode = RelativeCoordinates;
-        case PathSegLineToVerticalAbs:
-            emitLineToVerticalSegment(segment);
-            break;
-        case PathSegClosePath:
-            m_consumer->closePath();
-            // Reset m_currentPoint for the next path.
-            if (m_pathParsingMode == NormalizedParsing)
+            switch (segment.command) {
+            case PathSegMoveToRel:
+                m_mode = RelativeCoordinates;
+            case PathSegMoveToAbs:
+                emitMoveToSegment(segment);
+                break;
+            case PathSegLineToRel:
+                m_mode = RelativeCoordinates;
+            case PathSegLineToAbs:
+                emitLineToSegment(segment);
+                break;
+            case PathSegLineToHorizontalRel:
+                m_mode = RelativeCoordinates;
+            case PathSegLineToHorizontalAbs:
+                emitLineToHorizontalSegment(segment);
+                break;
+            case PathSegLineToVerticalRel:
+                m_mode = RelativeCoordinates;
+            case PathSegLineToVerticalAbs:
+                emitLineToVerticalSegment(segment);
+                break;
+            case PathSegClosePath:
+                m_consumer->closePath();
+                // Reset m_currentPoint for the next path.
                 m_currentPoint = m_subPathPoint;
-            break;
-        case PathSegCurveToCubicRel:
-            m_mode = RelativeCoordinates;
-        case PathSegCurveToCubicAbs:
-            emitCurveToCubicSegment(segment);
-            break;
-        case PathSegCurveToCubicSmoothRel:
-            m_mode = RelativeCoordinates;
-        case PathSegCurveToCubicSmoothAbs:
-            emitCurveToCubicSmoothSegment(segment);
-            break;
-        case PathSegCurveToQuadraticRel:
-            m_mode = RelativeCoordinates;
-        case PathSegCurveToQuadraticAbs:
-            emitCurveToQuadraticSegment(segment);
-            break;
-        case PathSegCurveToQuadraticSmoothRel:
-            m_mode = RelativeCoordinates;
-        case PathSegCurveToQuadraticSmoothAbs:
-            emitCurveToQuadraticSmoothSegment(segment);
-            break;
-        case PathSegArcRel:
-            m_mode = RelativeCoordinates;
-        case PathSegArcAbs:
-            emitArcToSegment(segment);
-            break;
-        default:
-            ASSERT_NOT_REACHED();
+                break;
+            case PathSegCurveToCubicRel:
+                m_mode = RelativeCoordinates;
+            case PathSegCurveToCubicAbs:
+                emitCurveToCubicSegment(segment);
+                break;
+            case PathSegCurveToCubicSmoothRel:
+                m_mode = RelativeCoordinates;
+            case PathSegCurveToCubicSmoothAbs:
+                emitCurveToCubicSmoothSegment(segment);
+                break;
+            case PathSegCurveToQuadraticRel:
+                m_mode = RelativeCoordinates;
+            case PathSegCurveToQuadraticAbs:
+                emitCurveToQuadraticSegment(segment);
+                break;
+            case PathSegCurveToQuadraticSmoothRel:
+                m_mode = RelativeCoordinates;
+            case PathSegCurveToQuadraticSmoothAbs:
+                emitCurveToQuadraticSmoothSegment(segment);
+                break;
+            case PathSegArcRel:
+                m_mode = RelativeCoordinates;
+            case PathSegArcAbs:
+                emitArcToSegment(segment);
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+            }
+        } else {
+            PathCoordinateMode mode = AbsoluteCoordinates;
+
+            switch (segment.command) {
+            case PathSegMoveToRel:
+                mode = RelativeCoordinates;
+            case PathSegMoveToAbs:
+                m_consumer->moveTo(segment.targetPoint, mode);
+                break;
+            case PathSegLineToRel:
+                mode = RelativeCoordinates;
+            case PathSegLineToAbs:
+                m_consumer->lineTo(segment.targetPoint, mode);
+                break;
+            case PathSegLineToHorizontalRel:
+                mode = RelativeCoordinates;
+            case PathSegLineToHorizontalAbs:
+                m_consumer->lineToHorizontal(segment.targetPoint.x(), mode);
+                break;
+            case PathSegLineToVerticalRel:
+                mode = RelativeCoordinates;
+            case PathSegLineToVerticalAbs:
+                m_consumer->lineToVertical(segment.targetPoint.y(), mode);
+                break;
+            case PathSegClosePath:
+                m_consumer->closePath();
+                break;
+            case PathSegCurveToCubicRel:
+                mode = RelativeCoordinates;
+            case PathSegCurveToCubicAbs:
+                m_consumer->curveToCubic(segment.point1, segment.point2, segment.targetPoint, mode);
+                break;
+            case PathSegCurveToCubicSmoothRel:
+                mode = RelativeCoordinates;
+            case PathSegCurveToCubicSmoothAbs:
+                m_consumer->curveToCubicSmooth(segment.point2, segment.targetPoint, mode);
+                break;
+            case PathSegCurveToQuadraticRel:
+                mode = RelativeCoordinates;
+            case PathSegCurveToQuadraticAbs:
+                m_consumer->curveToQuadratic(segment.point1, segment.targetPoint, mode);
+                break;
+            case PathSegCurveToQuadraticSmoothRel:
+                mode = RelativeCoordinates;
+            case PathSegCurveToQuadraticSmoothAbs:
+                m_consumer->curveToQuadraticSmooth(segment.targetPoint, mode);
+                break;
+            case PathSegArcRel:
+                mode = RelativeCoordinates;
+            case PathSegArcAbs:
+                m_consumer->arcTo(segment.arcRadii().x(), segment.arcRadii().y(), segment.arcAngle(), segment.arcLarge, segment.arcSweep, segment.targetPoint, mode);
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+            }
         }
+
         if (!m_consumer->continueConsuming())
             return true;
 
         m_lastCommand = segment.command;
 
         if (m_lastCommand != PathSegCurveToCubicAbs
             && m_lastCommand != PathSegCurveToCubicRel
             && m_lastCommand != PathSegCurveToCubicSmoothAbs
             && m_lastCommand != PathSegCurveToCubicSmoothRel
             && m_lastCommand != PathSegCurveToQuadraticAbs
@@ skipping 88 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;
 }
 
 }