Rename Path to Path2D

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 26 matching lines @@
 #include "bindings/v8/ExceptionMessages.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fetch/ImageResource.h"
+#include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/TextMetrics.h"
 #include "core/html/canvas/CanvasGradient.h"
 #include "core/html/canvas/CanvasPattern.h"
 #include "core/html/canvas/CanvasStyle.h"
-#include "core/html/canvas/DOMPath.h"
-#include "core/frame/ImageBitmap.h"
+#include "core/html/canvas/DOMPath2D.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderTheme.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/DrawLooper.h"
 #include "platform/text/TextRun.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CheckedArithmetic.h"
@@ skipping 742 matching lines @@
     if (state().m_fillStyle && state().m_fillStyle->isEquivalentCMYKA(c, m, y, k, a))
         return;
     setFillStyle(CanvasStyle::createFromCMYKAChannels(c, m, y, k, a));
 }
 
 void CanvasRenderingContext2D::beginPath()
 {
     m_path.clear();
 }
 
-PassRefPtr<DOMPath> CanvasRenderingContext2D::currentPath()
+PassRefPtr<DOMPath2D> CanvasRenderingContext2D::currentPath()
 {
-    return DOMPath::create(m_path);
+    return DOMPath2D::create(m_path);
 }
 
-void CanvasRenderingContext2D::setCurrentPath(DOMPath* path)
+void CanvasRenderingContext2D::setCurrentPath(DOMPath2D* path)
 {
     if (!path)
         return;
     m_path = path->path();
 }
 
 static bool validateRectForCanvas(float& x, float& y, float& width, float& height)
 {
     if (!std::isfinite(x) | !std::isfinite(y) | !std::isfinite(width) | !std::isfinite(height))
         return false;
@@ skipping 80 matching lines @@
     }
 
     c->setFillRule(windRule);
 }
 
 void CanvasRenderingContext2D::fill(const String& windingRuleString)
 {
     fillInternal(m_path, windingRuleString);
 }
 
-void CanvasRenderingContext2D::fill(DOMPath* domPath, const String& windingRuleString)
+void CanvasRenderingContext2D::fill(DOMPath2D* domPath, const String& windingRuleString)
 {
     fillInternal(domPath->path(), windingRuleString);
 }
 
 void CanvasRenderingContext2D::strokeInternal(const Path& path)
 {
     if (path.isEmpty()) {
         return;
     }
     GraphicsContext* c = drawingContext();
@@ skipping 17 matching lines @@
         c->strokePath(path);
         didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::stroke()
 {
     strokeInternal(m_path);
 }
 
-void CanvasRenderingContext2D::stroke(DOMPath* domPath)
+void CanvasRenderingContext2D::stroke(DOMPath2D* domPath)
 {
     strokeInternal(domPath->path());
 }
 
 void CanvasRenderingContext2D::clipInternal(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(path, newWindRule);
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
-void CanvasRenderingContext2D::clip(DOMPath* domPath, const String& windingRuleString)
+void CanvasRenderingContext2D::clip(DOMPath2D* domPath, const String& windingRuleString)
 {
     clipInternal(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)
@@ skipping 1431 matching lines @@
     const int focusRingWidth = 5;
     const int focusRingOutline = 0;
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
 
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore