Add versions of stroke, fill, and clip that take a Path parameter.

Source/core/html/canvas/CanvasRenderingContext2D.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, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 865 matching lines @@
     if (windingRuleString == "nonzero")
         windRule = RULE_NONZERO;
     else if (windingRuleString == "evenodd")
         windRule = RULE_EVENODD;
     else
         return false;
 
     return true;
 }
 
-void CanvasRenderingContext2D::fill(const String& windingRuleString)
+void CanvasRenderingContext2D::fillImpl(const Path& path, const String& windingRuleString)
 {
+    if (path.isEmpty()) {
+        return;
+    }
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
     FloatRect clipBounds;
     if (!drawingContext()->getTransformedClipBounds(&clipBounds))
         return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
-    if (!m_path.isEmpty()) {
-        WindRule windRule = c->fillRule();
-        WindRule newWindRule = RULE_NONZERO;
-        if (!parseWinding(windingRuleString, newWindRule))
-            return;
-        c->setFillRule(newWindRule);
+    WindRule windRule = c->fillRule();
+    WindRule newWindRule = RULE_NONZERO;
+    if (!parseWinding(windingRuleString, newWindRule))
+        return;
+    c->setFillRule(newWindRule);
 
-        if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-            fullCanvasCompositedFill(m_path);
-            didDraw(clipBounds);
-        } else if (state().m_globalComposite == CompositeCopy) {
-            clearCanvas();
-            c->fillPath(m_path);
-            didDraw(clipBounds);
-        } else {
-            FloatRect dirtyRect;
-            if (computeDirtyRect(m_path.boundingRect(), clipBounds, &dirtyRect)) {
-                c->fillPath(m_path);
-                didDraw(dirtyRect);
-            }
+    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
+        fullCanvasCompositedFill(path);
+        didDraw(clipBounds);
+    } else if (state().m_globalComposite == CompositeCopy) {
+        clearCanvas();
+        c->fillPath(path);
+        didDraw(clipBounds);
+    } else {
+        FloatRect dirtyRect;
+        if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {
+            c->fillPath(path);
+            didDraw(dirtyRect);
         }
+    }
 
-        c->setFillRule(windRule);
-    }
+    c->setFillRule(windRule);
 }
 
-void CanvasRenderingContext2D::stroke()
+void CanvasRenderingContext2D::fill(const String& windingRuleString)
 {
+    this->fillImpl(m_path, windingRuleString);
+}
+
+void CanvasRenderingContext2D::fill(DOMPath* domPath, const String& windingRuleString)
+{
+    this->fillImpl(domPath->path(), windingRuleString);
+}
+
+void CanvasRenderingContext2D::strokeImpl(const Path& path)
+{
+    if (path.isEmpty()) {
+        return;
+    }
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->strokeGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
-    if (!m_path.isEmpty()) {
-        FloatRect bounds = m_path.boundingRect();
-        inflateStrokeRect(bounds);
-        FloatRect dirtyRect;
-        if (computeDirtyRect(bounds, &dirtyRect)) {
-            c->strokePath(m_path);
-            didDraw(dirtyRect);
-        }
+    FloatRect bounds = path.boundingRect();
+    inflateStrokeRect(bounds);
+    FloatRect dirtyRect;
+    if (computeDirtyRect(bounds, &dirtyRect)) {
+        c->strokePath(path);
+        didDraw(dirtyRect);
     }
 }
 
-void CanvasRenderingContext2D::clip(const String& windingRuleString)
+void CanvasRenderingContext2D::stroke()
+{
+    this->strokeImpl(m_path);
+}
+
+void CanvasRenderingContext2D::stroke(DOMPath* domPath)
+{
+    this->strokeImpl(domPath->path());
+}
+
+void CanvasRenderingContext2D::clipImpl(const Path& path, const String& windingRuleString)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     WindRule newWindRule = RULE_NONZERO;
     if (!parseWinding(windingRuleString, newWindRule))
         return;
 
     realizeSaves();
-    c->canvasClip(m_path, newWindRule);
+    c->canvasClip(path, newWindRule);
+}
+
+void CanvasRenderingContext2D::clip(const String& windingRuleString)
+{
+    this->clipImpl(m_path, windingRuleString);
+}
+
+void CanvasRenderingContext2D::clip(DOMPath* domPath, const String& windingRuleString)
+{
+    this->clipImpl(domPath->path(), windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return false;
     if (!state().m_invertibleCTM)
         return false;
 
@@ skipping 1451 matching lines @@
     const int focusRingWidth = 5;
     const int focusRingOutline = 0;
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
 
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore