Simplify conversion of quadratic bezier segments

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 10 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/svg/SVGPathParser.h"
 
 #include "core/svg/SVGPathSource.h"
 #include "platform/transforms/AffineTransform.h"
 #include "wtf/MathExtras.h"
 
-static const float gOneOverThree = 1 / 3.f;
-
 namespace blink {
 
 DEFINE_TRACE(SVGPathParser)
 {
     visitor->trace(m_source);
     visitor->trace(m_consumer);
 }
 
 void SVGPathParser::parseClosePathSegment()
 {
@@ skipping 128 matching lines @@
         targetPoint += m_currentPoint;
     }
 
     m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
     m_controlPoint = point2;
     m_currentPoint = targetPoint;
     return true;
 }
 
+// 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);
+}
+
 bool SVGPathParser::parseCurveToQuadraticSegment()
 {
     FloatPoint point1;
     FloatPoint targetPoint;
     if (!m_source->parseCurveToQuadraticSegment(point1, targetPoint))
         return false;
 
     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());
+        m_controlPoint += m_currentPoint;
         targetPoint += m_currentPoint;
     }
-    point1.scale(gOneOverThree, gOneOverThree);
-    point2.scale(gOneOverThree, gOneOverThree);
+    point1 = blendPoints(m_currentPoint, m_controlPoint);
+    FloatPoint point2 = blendPoints(targetPoint, m_controlPoint);
 
     m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-    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_pathParsingMode == UnalteredParsing) {
         m_consumer->curveToQuadraticSmooth(targetPoint, m_mode);
         return true;
     }
     if (m_lastCommand != PathSegCurveToQuadraticAbs
         && m_lastCommand != PathSegCurveToQuadraticRel
         && m_lastCommand != PathSegCurveToQuadraticSmoothAbs
         && m_lastCommand != PathSegCurveToQuadraticSmoothRel)
         m_controlPoint = m_currentPoint;
 
-    FloatPoint cubicPoint = reflectedPoint(m_currentPoint, m_controlPoint);
-    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;
+    if (m_mode == RelativeCoordinates)
         targetPoint += m_currentPoint;
-    }
-    point1.scale(gOneOverThree, gOneOverThree);
-    point2.scale(gOneOverThree, gOneOverThree);
+
+    m_controlPoint = reflectedPoint(m_currentPoint, m_controlPoint);
+    FloatPoint point1 = blendPoints(m_currentPoint, m_controlPoint);
+    FloatPoint point2 = blendPoints(targetPoint, m_controlPoint);
 
     m_consumer->curveToCubic(point1, point2, targetPoint, AbsoluteCoordinates);
 
-    m_controlPoint = cubicPoint;
     m_currentPoint = targetPoint;
     return true;
 }
 
 bool SVGPathParser::parseArcToSegment()
 {
     float rx;
     float ry;
     float angle;
     bool largeArc;
@@ skipping 222 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;
 }
 
 }