Simplify SVGPathBlender::blendArcToSegment

Source/core/svg/SVGPathBlender.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010, 2011. 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 59 matching lines @@
     float animValue = blend(from, m_fromMode == AbsoluteCoordinates ? to + toValue : to - toValue, m_progress);
 
     if (m_isInFirstHalfOfAnimation)
         return animValue;
 
     // Transform the animated point to the coordinate mode, needed for the current progress.
     float currentValue = blend(fromValue, toValue, m_progress);
     return m_toMode == AbsoluteCoordinates ? animValue + currentValue : animValue - currentValue;
 }
 
+FloatPoint SVGPathBlender::blendAnimatedFloatPointSameCoordinates(const FloatPoint& fromPoint, const FloatPoint& toPoint)
+{
+    if (m_addTypesCount) {
+        FloatPoint repeatedToPoint = toPoint;
+        repeatedToPoint.scale(m_addTypesCount, m_addTypesCount);
+        return fromPoint + repeatedToPoint;
+    }
+    return blendFloatPoint(fromPoint, toPoint, m_progress);
+}
+
 FloatPoint SVGPathBlender::blendAnimatedFloatPoint(const FloatPoint& fromPoint, const FloatPoint& toPoint)
 {
-    if (m_addTypesCount) {
-        ASSERT(m_fromMode == m_toMode);
-        FloatPoint repeatedToPoint = toPoint;
-        repeatedToPoint.scale(m_addTypesCount, m_addTypesCount);
-        return fromPoint + repeatedToPoint;
-    }
-
     if (m_fromMode == m_toMode)
-        return blendFloatPoint(fromPoint, toPoint, m_progress);
+        return blendAnimatedFloatPointSameCoordinates(fromPoint, toPoint);
 
     // Transform toPoint to the coordinate mode of fromPoint
     FloatPoint animatedPoint = toPoint;
     if (m_fromMode == AbsoluteCoordinates)
         animatedPoint += m_toCurrentPoint;
     else
         animatedPoint.move(-m_toCurrentPoint.x(), -m_toCurrentPoint.y());
 
     animatedPoint = blendFloatPoint(fromPoint, animatedPoint, m_progress);
 
@@ skipping 147 matching lines @@
     float toRx = 0;
     float toRy = 0;
     float toAngle = 0;
     bool toLargeArc = false;
     bool toSweep = false;
     FloatPoint toTargetPoint;
     if ((m_fromSource->hasMoreData() && !m_fromSource->parseArcToSegment(fromRx, fromRy, fromAngle, fromLargeArc, fromSweep, fromTargetPoint))
         || !m_toSource->parseArcToSegment(toRx, toRy, toAngle, toLargeArc, toSweep, toTargetPoint))
         return false;
 
+    ASSERT(!m_addTypesCount || m_fromMode == m_toMode);
+
+    FloatPoint blendedRadii = blendAnimatedFloatPointSameCoordinates(FloatPoint(fromRx, fromRy), FloatPoint(toRx, toRy));
+    float blendedAngle = blendAnimatedFloatPointSameCoordinates(FloatPoint(fromAngle, 0), FloatPoint(toAngle, 0)).x();
+    bool blendedLargeArc;
+    bool blendedSweep;
+
     if (m_addTypesCount) {
-        ASSERT(m_fromMode == m_toMode);
-        FloatPoint scaledToTargetPoint = toTargetPoint;
-        scaledToTargetPoint.scale(m_addTypesCount, m_addTypesCount);
-        m_consumer->arcTo(fromRx + toRx * m_addTypesCount,
-                          fromRy + toRy * m_addTypesCount,
-                          fromAngle + toAngle * m_addTypesCount,
-                          fromLargeArc || toLargeArc,
-                          fromSweep || toSweep,
-                          fromTargetPoint + scaledToTargetPoint,
-                          m_fromMode);
+        blendedLargeArc = fromLargeArc || toLargeArc;
+        blendedSweep = fromSweep || toSweep;
     } else {
-        m_consumer->arcTo(blend(fromRx, toRx, m_progress),
-                          blend(fromRy, toRy, m_progress),
-                          blend(fromAngle, toAngle, m_progress),
-                          m_isInFirstHalfOfAnimation ? fromLargeArc : toLargeArc,
-                          m_isInFirstHalfOfAnimation ? fromSweep : toSweep,
-                          blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint),
-                          m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode);
+        blendedLargeArc = m_isInFirstHalfOfAnimation ? fromLargeArc : toLargeArc;
+        blendedSweep = m_isInFirstHalfOfAnimation ? fromSweep : toSweep;
     }
+
+    m_consumer->arcTo(
+        blendedRadii.x(), blendedRadii.y(), blendedAngle, blendedLargeArc, blendedSweep,
+        blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint),
+        m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode);
+
     m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint;
     m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint;
     return true;
 }
 
 static inline PathCoordinateMode coordinateModeOfCommand(const SVGPathSegType& type)
 {
     if (type < PathSegMoveToAbs)
         return AbsoluteCoordinates;
 
@@ skipping 102 matching lines @@
         if (m_fromSource->hasMoreData() != m_toSource->hasMoreData())
             return false;
         if (!m_fromSource->hasMoreData() || !m_toSource->hasMoreData())
             return true;
     }
 
     return true;
 }
 
 }