Rework the SVGPathConsumer interface

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 29 matching lines @@
 {
     // If the path is empty it is still valid, so return true.
     if (!m_source->hasMoreData())
         return true;
 
     SVGPathSegType command = m_source->peekSegmentType();
     // Path must start with moveTo.
     return command == PathSegMoveToAbs || command == PathSegMoveToRel;
 }
 
-
 class NormalizingConsumer {
     STACK_ALLOCATED();
 public:
     NormalizingConsumer(SVGPathConsumer* consumer)
         : m_consumer(consumer)
         , m_lastCommand(PathSegUnknown)
     {
         ASSERT(m_consumer);
     }
 
@@ skipping 129 matching lines @@
             // decomposeArcToCubic() has already emitted the normalized
             // segments, so set command to PathSegArcAbs, to skip any further
             // emit.
             segment.command = PathSegArcAbs;
         }
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
-    switch (segment.command) {
-    case PathSegMoveToAbs:
-        m_consumer->moveTo(segment.targetPoint, AbsoluteCoordinates);
-        break;
-    case PathSegLineToAbs:
-        m_consumer->lineTo(segment.targetPoint, AbsoluteCoordinates);
-        break;
-    case PathSegClosePath:
-        m_consumer->closePath();
-        break;
-    case PathSegCurveToCubicAbs:
-        m_consumer->curveToCubic(segment.point1, segment.point2, segment.targetPoint, AbsoluteCoordinates);
-        break;
-    case PathSegArcAbs:
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
+    if (segment.command != PathSegArcAbs)
+        m_consumer->emitSegment(segment);
 
     m_currentPoint = segment.targetPoint;
 
     if (!isCubicCommand(originalCommand) && !isQuadraticCommand(originalCommand))
         m_controlPoint = m_currentPoint;
 
     m_lastCommand = originalCommand;
 }
 
 bool SVGPathParser::parsePathDataFromSource(PathParsingMode pathParsingMode, bool checkForInitialMoveTo)
 {
     ASSERT(m_source);
     ASSERT(m_consumer);
 
     if (checkForInitialMoveTo && !initialCommandIsMoveTo())
         return false;
 
     NormalizingConsumer normalizer(m_consumer);
 
     while (m_source->hasMoreData()) {
         PathSegmentData segment = m_source->parseSegment();
         if (segment.command == PathSegUnknown)
             return false;
 
         if (pathParsingMode == NormalizedParsing) {
             normalizer.emitSegment(segment);
         } 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();
-            }
+            m_consumer->emitSegment(segment);
         }
 
         if (!m_consumer->continueConsuming())
             return true;
 
         if (m_source->hasMoreData())
             m_consumer->incrementPathSegmentCount();
     }
     return true;
 }
@@ skipping 85 matching lines @@
         float sinEndTheta = sinf(endTheta);
         float cosEndTheta = cosf(endTheta);
 
         point1 = FloatPoint(cosStartTheta - t * sinStartTheta, sinStartTheta + t * cosStartTheta);
         point1.move(centerPoint.x(), centerPoint.y());
         FloatPoint targetPoint = FloatPoint(cosEndTheta, sinEndTheta);
         targetPoint.move(centerPoint.x(), centerPoint.y());
         point2 = targetPoint;
         point2.move(t * sinEndTheta, -t * cosEndTheta);
 
-        m_consumer->curveToCubic(pointTransform.mapPoint(point1), pointTransform.mapPoint(point2),
-                                 pointTransform.mapPoint(targetPoint), AbsoluteCoordinates);
+        PathSegmentData cubicSegment;
+        cubicSegment.command = PathSegCurveToCubicAbs;
+        cubicSegment.point1 = pointTransform.mapPoint(point1);
+        cubicSegment.point2 = pointTransform.mapPoint(point2);
+        cubicSegment.targetPoint = pointTransform.mapPoint(targetPoint);
+
+        m_consumer->emitSegment(cubicSegment);
     }
     return true;
 }
 
 }