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 112 matching lines @@
     FloatPoint p2 = FloatPoint(x2, y2);
 
     if (!m_path.hasCurrentPoint())
         m_path.moveTo(p1);
     else if (p1 == m_path.currentPoint() || p1 == p2 || !r)
         lineTo(x1, y1);
     else
         m_path.addArcTo(p1, p2, r);
 }
 
-void CanvasPathMethods::arc(float x, float y, float r, float sa, float ea, bool anticlockwise, ExceptionCode& ec)
+static float adjustEndAngle(float startAngle, float endAngle, bool anticlockwise)
+{
+    // If 'sa' and 'ea' differ by more than 2Pi, just add a circle starting/ending at 'sa'.
+    if (anticlockwise && startAngle - endAngle >= 2 * piFloat)
+        return startAngle - 2 * piFloat;
+    if (!anticlockwise && endAngle - startAngle >= 2 * piFloat)
+        return startAngle + 2 * piFloat;
+    return endAngle;
+}
+
+void CanvasPathMethods::arc(float x, float y, float r, float startAngle, float endAngle, bool anticlockwise, ExceptionCode& ec)
 {
     ec = 0;
-    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(r) || !std::isfinite(sa) || !std::isfinite(ea))
+    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(r) || !std::isfinite(startAngle) || !std::isfinite(endAngle))
         return;
 
     if (r < 0) {
         ec = INDEX_SIZE_ERR;
         return;
     }
 
-    if (!r || sa == ea) {
+    if (!r || startAngle == endAngle) {
         // The arc is empty but we still need to draw the connecting line.
-        lineTo(x + r * cosf(sa), y + r * sinf(sa));
+        lineTo(x + r * cosf(startAngle), y + r * sinf(startAngle));
         return;
     }
 
     if (!isTransformInvertible())
         return;
 
-    // If 'sa' and 'ea' differ by more than 2Pi, just add a circle starting/ending at 'sa'.
-    if (anticlockwise && sa - ea >= 2 * piFloat) {
-        m_path.addArc(FloatPoint(x, y), r, sa, sa - 2 * piFloat, anticlockwise);
+    float adjustedEndAngle = adjustEndAngle(startAngle, endAngle, anticlockwise);
+    m_path.addArc(FloatPoint(x, y), r, startAngle, adjustedEndAngle, anticlockwise);
+}
+
+void CanvasPathMethods::ellipse(float x, float y, float rx, float ry, float rot, float sa, float endAngle, bool anticlockwise, ExceptionCode& ec)
+{
+    ec = 0;
+    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(rx) || !std::isfinite(ry) || !std::isfinite(rot) || !std::isfinite(sa) || !std::isfinite(endAngle))
         return;
-    }
-    if (!anticlockwise && ea - sa >= 2 * piFloat) {
-        m_path.addArc(FloatPoint(x, y), r, sa, sa + 2 * piFloat, anticlockwise);
+
+    if (rx < 0 || ry < 0) {
+        ec = INDEX_SIZE_ERR;
         return;
     }
 
-    m_path.addArc(FloatPoint(x, y), r, sa, ea, anticlockwise);
+    if (!rx || !ry || sa == endAngle) {

[aandrey, 2013/07/09 13:49:56]

sa -> startAngle

[dshwang, 2013/07/09 14:42:05]

oops, thx!

[alph, 2013/07/09 14:43:09]

If one of radii is not zero I'd expect the stroked ellipse to degenerate into a
line, not to the empty thing.

+        // The ellipse is empty but we still need to draw the connecting line to start point.
+        lineTo(x + rx * cosf(sa + rot), y + rx * sinf(sa + rot));

[alph, 2013/07/09 14:16:00]

rx used twice here.
Also I suppose rotation should also rotate ellipse axes, while here it just
affects starting point.

[dshwang, 2013/07/09 14:42:05]

thx for review. Yeah, using rx twice is wrong.

how about as follows:?
lineTo(x + rx * cosf(sa + rot), y + ry * sinf(sa + rot));
The point (x + rx * cosf(sa + rot), y + ry * sinf(sa + rot)) is on the ellipse.

It means to draw line to start point.
It is because arc() also draw line to start point.
line 156: lineTo(x + r * cosf(startAngle), y + r * sinf(startAngle));

The canvas spec does not describe this edge case. So I just match ellipse to
arc.

[alph, 2013/07/09 15:16:35]

I don't like it. It works for arc because its radii are the same.
If you do it this way for ellipse, then in rotated case with rx!=ry you'll be
getting distinct points when startAndle is close to endAngle and when they are
equal. So if someone makes an animation where endAngle decreases down to
startAngle, suddenly it will jump to a distinct location when endAngle reaches
startAngle. That doesn't seem what people would expect.

Here's an example:
x = 0
y = 0
rx = 100
ry = 5
rot = pi/2
startAngle = 0
endAngle = 1e-6
The point should be (0;100), while for endAngle=0 you'll be getting (0;5)

+        return;
+    }
+
+    if (!isTransformInvertible())
+        return;
+
+    float adjustedEndAngle = adjustEndAngle(sa, endAngle, anticlockwise);
+    m_path.addEllipse(FloatPoint(x, y), rx, ry, rot, sa, 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));
 }
 }