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 20 matching lines @@
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/canvas/CanvasPathMethods.h"
 
 #include "bindings/v8/ExceptionState.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 128 matching lines @@
     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);
+    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)

[Stephen White, 2013/08/27 14:23:50]

I'm a little confused by this loop (and the one below). Isn't a degenerate
ellipse a single line? Perhaps adding a comment (and/or a reference to the spec,
although I couldn't find this algorithm there) might help.

[Justin Novosad, 2013/08/27 17:51:03]

I think the idea to to generate a flat quad to draw said line? 
Definitely needs more explaining.  Also I am not 100% convinced this does the
right thing in all cases

[dshwang, 2013/08/27 18:54:17]

I added detail explanations as comments.
To verify this implementation, I made
fast/canvas/canvas-ellipse-connecting-line.html that covers extensive cases.

And @alph reviewed it very carefully.

+            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, ExceptionState& es)
+{
+    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) {
+        es.throwDOMException(IndexSizeError);
+        return;
+    }
+
+    if (!isTransformInvertible())

[Justin Novosad, 2013/08/27 17:51:03]

This early exit is not in the spec.  If the implementation can't handle
non-invertible transforms, then that should be fixed.  Transforming an
elliptical arc by a non-invertible transform is perfectly tractable.  It gives
an area of zero, so ignoring it is fine when the path is filled. When stroked
however, the ellipse should be rendered as a line.

[dshwang, 2013/08/27 18:54:17]

Good concern.
However, all primitives early exit as well as ellipse: moveTo, lineTo,
quadraticCurveTo, bezierCurveTo, arcTo, arc, rect.

I also can not find the spec about invertible current transform.

If ellipse has problem, all primitives have also problem. We need to handle them
together in the future if you are right.

+        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));
 }
 }