Add support for new canvas ellipse method.

Source/core/html/canvas/CanvasPathMethods.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  * Copyright (C) 2012, 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 19 matching lines @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/canvas/CanvasPathMethods.h"
 
 #include "core/dom/ExceptionCode.h"
 #include "core/platform/graphics/FloatRect.h"
+#include "core/platform/graphics/transforms/AffineTransform.h"
 #include <wtf/MathExtras.h>
 
 namespace WebCore {
 
 void CanvasPathMethods::closePath()
 {
     if (m_path.isEmpty())
         return;
 
     FloatRect boundRect = m_path.boundingRect();
@@ skipping 76 matching lines @@
         m_path.moveTo(p1);
     else if (p1 == m_path.currentPoint() || p1 == p2 || !r)
         lineTo(x1, y1);
     else
         m_path.addArcTo(p1, p2, r);
 }
 
 static float adjustEndAngle(float startAngle, float endAngle, bool anticlockwise)
 {
     float twoPi = 2 * piFloat;
+    float newEndAngle = endAngle;
     /* http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-context-2d-arc
      * If the anticlockwise argument is false and endAngle-startAngle is equal to or greater than 2π, or,
      * if the anticlockwise argument is true and startAngle-endAngle is equal to or greater than 2π,
      * then the arc is the whole circumference of this ellipse.
      */
     if (!anticlockwise && endAngle - startAngle >= twoPi)
-        return startAngle + twoPi + fmodf(endAngle - startAngle, twoPi);
-    if (anticlockwise && startAngle - endAngle >= twoPi)
-        return startAngle - twoPi - fmodf(startAngle - endAngle, twoPi);
+        newEndAngle = startAngle + twoPi + fmodf(endAngle - startAngle, twoPi);
+    else if (anticlockwise && startAngle - endAngle >= twoPi)
+        newEndAngle = startAngle - twoPi - fmodf(startAngle - endAngle, twoPi);
 
     /*
      * Otherwise, the arc is the path along the circumference of this ellipse from the start point to the end point,
      * going anti-clockwise if the anticlockwise argument is true, and clockwise otherwise.
      * Since the points are on the ellipse, as opposed to being simply angles from zero,
      * the arc can never cover an angle greater than 2π radians.
      */
-    if (!anticlockwise && startAngle > endAngle)
-        return startAngle + (twoPi - fmodf(startAngle - endAngle, twoPi));
-    if (anticlockwise && startAngle < endAngle)
-        return startAngle - (twoPi - fmodf(endAngle - startAngle, twoPi));
+    else if (!anticlockwise && startAngle > endAngle)
+        newEndAngle = startAngle + (twoPi - fmodf(startAngle - endAngle, twoPi));
+    else if (anticlockwise && startAngle < endAngle)
+        newEndAngle = startAngle - (twoPi - fmodf(endAngle - startAngle, twoPi));
 
-    return endAngle;
+    ASSERT(std::abs(newEndAngle - startAngle) < 4 * piFloat);
+    return newEndAngle;
 }
 
 void CanvasPathMethods::arc(float x, float y, float radius, float startAngle, float endAngle, bool anticlockwise, ExceptionCode& ec)
 {
     ec = 0;
     if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radius) || !std::isfinite(startAngle) || !std::isfinite(endAngle))
         return;
 
     if (radius < 0) {
         ec = IndexSizeError;
         return;
     }
 
     if (!isTransformInvertible())
         return;
 
     if (!radius || startAngle == endAngle) {
         // The arc is empty but we still need to draw the connecting line.
         lineTo(x + radius * cosf(startAngle), y + radius * sinf(startAngle));
         return;
     }
 
     float adjustedEndAngle = adjustEndAngle(startAngle, endAngle, anticlockwise);
     m_path.addArc(FloatPoint(x, y), radius, startAngle, adjustedEndAngle, anticlockwise);
 }
 
+inline static void lineToFloatPoint(CanvasPathMethods* path, const FloatPoint& p)
+{
+    path->lineTo(p.x(), p.y());
+}
+
+inline static FloatPoint getPointOnEllipse(float radiusX, float radiusY, float theta)
+{
+    return FloatPoint(radiusX * cosf(theta), radiusY * sinf(theta));
+}
+
+inline static void canonicalizeAngle(float* startAngle, float* endAngle)
+{
+    // Make 0 <= startAngle < 2*PI
+    float twoPi = 2 * piFloat;
+    float newStartAngle = *startAngle;
+    if (newStartAngle < 0)
+        newStartAngle = twoPi + fmodf(newStartAngle, -twoPi);
+    else
+        newStartAngle = fmodf(newStartAngle, twoPi);
+
+    float delta = newStartAngle - *startAngle;
+    *startAngle = newStartAngle;
+    *endAngle = *endAngle + delta;
+}
+
+static void degenerateEllipse(CanvasPathMethods* path, float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise)
+{
+    ASSERT(std::abs(endAngle - startAngle) < 4 * piFloat);
+
+    FloatPoint center(x, y);
+    AffineTransform rotationMatrix;
+    rotationMatrix.rotate(rad2deg(rotation));
+    lineToFloatPoint(path, center + rotationMatrix.mapPoint(getPointOnEllipse(radiusX, radiusY, startAngle)));
+    if ((!radiusX && !radiusY) || startAngle == endAngle)
+        return;
+
+    canonicalizeAngle(&startAngle, &endAngle);

[alph, 2013/07/10 13:38:04]

It seems that canonicalizeAngle should depend on anticlockwise, as endAngle
should be more than startAngle if !anticlockwise, and opposite otherwise.

Also I suggest to just inline it here and get rid of taking address operations
on startAngle, endAngle, as they might prohibit some compiler optimizations.

[dshwang, 2013/07/10 14:19:57]

canonicalizeAngle() is independent from whether anticlockwise or not.
canonicalizeAngle just translates pair(startAngle, endAngle) so that 0 <=
startAngle < 2*PI.

adjustEndAngle() guarantees relevant startAngle and endAngle, and
adjustEndAngle() works before this routine.

I respect your optimization concern, but imho it seems to be premature
optimization.
degenerateEllipse() would be rarely called, so I prefer a bit more readability.

[alph, 2013/07/10 15:22:30]

Sorry, missed that.
 

+    ASSERT(std::abs(endAngle - startAngle) < 4 * piFloat);
+
+    float halfPiFloat = piFloat * 0.5;
+    if (!anticlockwise) {
+        for (float angle = startAngle - fmodf(startAngle, halfPiFloat) + halfPiFloat; angle < endAngle; angle += halfPiFloat)
+            lineToFloatPoint(path, center + rotationMatrix.mapPoint(getPointOnEllipse(radiusX, radiusY, angle)));
+    } else {
+        for (float angle = startAngle - fmodf(startAngle, halfPiFloat); angle > endAngle; angle -= halfPiFloat)
+            lineToFloatPoint(path, center + rotationMatrix.mapPoint(getPointOnEllipse(radiusX, radiusY, angle)));
+    }
+
+    lineToFloatPoint(path, center + rotationMatrix.mapPoint(getPointOnEllipse(radiusX, radiusY, endAngle)));
+}
+
+void CanvasPathMethods::ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise, ExceptionCode& ec)
+{
+    ec = 0;
+    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radiusX) || !std::isfinite(radiusY) || !std::isfinite(rotation) || !std::isfinite(startAngle) || !std::isfinite(endAngle))
+        return;
+
+    if (radiusX < 0 || radiusY < 0) {
+        ec = IndexSizeError;
+        return;
+    }
+
+    if (!isTransformInvertible())
+        return;
+
+    float adjustedEndAngle = adjustEndAngle(startAngle, endAngle, anticlockwise);
+    if (!radiusX || !radiusY || startAngle == adjustedEndAngle) {
+        // The ellipse is empty but we still need to draw the connecting line to start point.
+        degenerateEllipse(this, x, y, radiusX, radiusY, rotation, startAngle, adjustedEndAngle, anticlockwise);
+        return;
+    }
+
+    m_path.addEllipse(FloatPoint(x, y), radiusX, radiusY, rotation, startAngle, adjustedEndAngle, anticlockwise);
+}
+
 void CanvasPathMethods::rect(float x, float y, float width, float height)
 {
     if (!isTransformInvertible())
         return;
 
     if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) || !std::isfinite(height))
         return;
 
     if (!width && !height) {
         m_path.moveTo(FloatPoint(x, y));
         return;
     }
 
     m_path.addRect(FloatRect(x, y, width, height));
 }
 }