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/Path2D.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 751 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<Path2D> CanvasRenderingContext2D::currentPath()
 {
-    return DOMPath::create(m_path);
+    return Path2D::create(m_path);
 }
 
-void CanvasRenderingContext2D::setCurrentPath(DOMPath* path)
+void CanvasRenderingContext2D::setCurrentPath(Path2D* 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, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::fill(Path2D* domPath, ExceptionState& exceptionState)
 {
     fill(domPath, "nonzero", exceptionState);
 }
 
-void CanvasRenderingContext2D::fill(DOMPath* domPath, const String& windingRuleString, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::fill(Path2D* domPath, const String& windingRuleString, ExceptionState& exceptionState)
 {
     if (!domPath) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
         return;
     }
 
     fillInternal(domPath->path(), windingRuleString);
 }
 
 void CanvasRenderingContext2D::strokeInternal(const Path& path)
@@ skipping 22 matching lines @@
         c->strokePath(path);
         didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::stroke()
 {
     strokeInternal(m_path);
 }
 
-void CanvasRenderingContext2D::stroke(DOMPath* domPath, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::stroke(Path2D* domPath, ExceptionState& exceptionState)
 {
     if (!domPath) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
         return;
     }
 
     strokeInternal(domPath->path());
 }
 
 void CanvasRenderingContext2D::clipInternal(const Path& path, const String& windingRuleString)
@@ skipping 13 matching lines @@
 
     realizeSaves();
     c->canvasClip(path, newWindRule);
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
-void CanvasRenderingContext2D::clip(DOMPath* domPath, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::clip(Path2D* domPath, ExceptionState& exceptionState)
 {
     clip(domPath, "nonzero", exceptionState);
 }
 
-void CanvasRenderingContext2D::clip(DOMPath* domPath, const String& windingRuleString, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString, ExceptionState& exceptionState)
 {
     if (!domPath) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
         return;
     }
 
     clipInternal(domPath->path(), windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString)
 {
     return isPointInPathInternal(m_path, x, y, windingRuleString);
 }
 
-bool CanvasRenderingContext2D::isPointInPath(DOMPath* domPath, const float x, const float y, ExceptionState& exceptionState)
+bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y, ExceptionState& exceptionState)
 {
     return isPointInPath(domPath, x, y, "nonzero", exceptionState);
 }
 
-bool CanvasRenderingContext2D::isPointInPath(DOMPath* domPath, const float x, const float y, const String& windingRuleString, ExceptionState& exceptionState)
+bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y, const String& windingRuleString, ExceptionState& exceptionState)
 {
     if (!domPath) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
         return false;
     }
 
     return isPointInPathInternal(domPath->path(), x, y, windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, const float x, const float y, const String& windingRuleString)
@@ skipping 15 matching lines @@
         return false;
 
     return path.contains(transformedPoint, windRule);
 }
 
 bool CanvasRenderingContext2D::isPointInStroke(const float x, const float y)
 {
     return isPointInStrokeInternal(m_path, x, y);
 }
 
-bool CanvasRenderingContext2D::isPointInStroke(DOMPath* domPath, const float x, const float y, ExceptionState& exceptionState)
+bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const float x, const float y, ExceptionState& exceptionState)
 {
     if (!domPath) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
         return false;
     }
 
     return isPointInStrokeInternal(domPath->path(), x, y);
 }
 
 bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const float x, const float y)
@@ skipping 1427 matching lines @@
     const int focusRingWidth = 5;
     const int focusRingOutline = 0;
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
 
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore