Pass segment to decomposeArcToCubic and let it handle exceptional cases

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 149 matching lines @@
     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 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) {
+    if (!decomposeArcToCubic(m_currentPoint, segment))
         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_controlPoint = FloatPoint();
     m_currentPoint = FloatPoint();
     m_subPathPoint = FloatPoint();
@@ skipping 138 matching lines @@
 
         if (m_source->hasMoreData())
             m_consumer->incrementPathSegmentCount();
     }
     return true;
 }
 
 // This works by converting the SVG arc to "simple" beziers.
 // Partly adapted from Niko's code in kdelibs/kdecore/svgicons.
 // See also SVG implementation notes: http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
-bool SVGPathParser::decomposeArcToCubic(float angle, float rx, float ry, const FloatPoint& start, const FloatPoint& end, bool largeArcFlag, bool sweepFlag)
+bool SVGPathParser::decomposeArcToCubic(const FloatPoint& currentPoint, const PathSegmentData& arcSegment)
 {
-    FloatSize midPointDistance = start - end;
+    // 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
+    float rx = fabsf(arcSegment.arcRadii().x());
+    float ry = fabsf(arcSegment.arcRadii().y());
+    if (!rx || !ry)
+        return false;
+
+    // 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.
+    if (arcSegment.targetPoint == currentPoint)
+        return false;
+
+    float angle = arcSegment.arcAngle();
+
+    FloatSize midPointDistance = currentPoint - arcSegment.targetPoint;
     midPointDistance.scale(0.5f);
 
     AffineTransform pointTransform;
     pointTransform.rotate(-angle);
 
     FloatPoint transformedMidPoint = pointTransform.mapPoint(FloatPoint(midPointDistance.width(), midPointDistance.height()));
     float squareRx = rx * rx;
     float squareRy = ry * ry;
     float squareX = transformedMidPoint.x() * transformedMidPoint.x();
     float squareY = transformedMidPoint.y() * transformedMidPoint.y();
 
     // Check if the radii are big enough to draw the arc, scale radii if not.
     // http://www.w3.org/TR/SVG/implnote.html#ArcCorrectionOutOfRangeRadii
     float radiiScale = squareX / squareRx + squareY / squareRy;
     if (radiiScale > 1) {
         rx *= sqrtf(radiiScale);
         ry *= sqrtf(radiiScale);
     }
 
     pointTransform.makeIdentity();
     pointTransform.scale(1 / rx, 1 / ry);
     pointTransform.rotate(-angle);
 
-    FloatPoint point1 = pointTransform.mapPoint(start);
-    FloatPoint point2 = pointTransform.mapPoint(end);
+    FloatPoint point1 = pointTransform.mapPoint(currentPoint);
+    FloatPoint point2 = pointTransform.mapPoint(arcSegment.targetPoint);
     FloatSize delta = point2 - point1;
 
     float d = delta.width() * delta.width() + delta.height() * delta.height();
     float scaleFactorSquared = std::max(1 / d - 0.25f, 0.f);
 
     float scaleFactor = sqrtf(scaleFactorSquared);
-    if (sweepFlag == largeArcFlag)
+    if (arcSegment.arcSweep == arcSegment.arcLarge)
         scaleFactor = -scaleFactor;
 
     delta.scale(scaleFactor);
     FloatPoint centerPoint = point1 + point2;
     centerPoint.scale(0.5f, 0.5f);
     centerPoint.move(-delta.height(), delta.width());
 
     float theta1 = FloatPoint(point1 - centerPoint).slopeAngleRadians();
     float theta2 = FloatPoint(point2 - centerPoint).slopeAngleRadians();
 
     float thetaArc = theta2 - theta1;
-    if (thetaArc < 0 && sweepFlag)
+    if (thetaArc < 0 && arcSegment.arcSweep)
         thetaArc += twoPiFloat;
-    else if (thetaArc > 0 && !sweepFlag)
+    else if (thetaArc > 0 && !arcSegment.arcSweep)
         thetaArc -= twoPiFloat;
 
     pointTransform.makeIdentity();
     pointTransform.rotate(angle);
     pointTransform.scale(rx, ry);
 
     // Some results of atan2 on some platform implementations are not exact enough. So that we get more
     // cubic curves than expected here. Adding 0.001f reduces the count of sgements to the correct count.
     int segments = ceilf(fabsf(thetaArc / (piOverTwoFloat + 0.001f)));
     for (int i = 0; i < segments; ++i) {
@@ skipping 15 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;
 }
 
 }