Use StrictTypeChecking for methods on CRC2D that accepts 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 1011 matching lines @@
     }
 
     c->setFillRule(windRule);
 }
 
 void CanvasRenderingContext2D::fill(const String& windingRuleString)
 {
     fillInternal(m_path, windingRuleString);
 }
 
-void CanvasRenderingContext2D::fill(Path2D* domPath, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::fill(Path2D* domPath)
 {
-    fill(domPath, "nonzero", exceptionState);
+    fill(domPath, "nonzero");
 }
 
-void CanvasRenderingContext2D::fill(Path2D* domPath, const String& windingRuleString, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::fill(Path2D* domPath, const String& windingRuleString)
 {
-    if (!domPath) {
-        exceptionState.throwTypeError(ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
-        return;
-    }
-
     fillInternal(domPath->path(), windingRuleString);
 }
 
 void CanvasRenderingContext2D::strokeInternal(const Path& path)
 {
     if (path.isEmpty()) {
         return;
     }
     GraphicsContext* c = drawingContext();
     if (!c) {
@@ skipping 16 matching lines @@
         c->strokePath(path);
         didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::stroke()
 {
     strokeInternal(m_path);
 }
 
-void CanvasRenderingContext2D::stroke(Path2D* domPath, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::stroke(Path2D* domPath)
 {
-    if (!domPath) {
-        exceptionState.throwTypeError(ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
-        return;
-    }
-
     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(Path2D* domPath, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::clip(Path2D* domPath)
 {
-    clip(domPath, "nonzero", exceptionState);
+    clip(domPath, "nonzero");
 }
 
-void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString)
 {
-    if (!domPath) {
-        exceptionState.throwTypeError(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(Path2D* domPath, const float x, const float y, ExceptionState& exceptionState)
+bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y)
 {
-    return isPointInPath(domPath, x, y, "nonzero", exceptionState);
+    return isPointInPath(domPath, x, y, "nonzero");
 }
 
-bool CanvasRenderingContext2D::isPointInPath(Path2D* 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)
 {
-    if (!domPath) {
-        exceptionState.throwTypeError(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)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return false;
     if (!state().m_invertibleCTM)
         return false;
 
     FloatPoint point(x, y);
     AffineTransform ctm = state().m_transform;
     FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
     if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))
         return false;
 
     WindRule windRule = RULE_NONZERO;
     if (!parseWinding(windingRuleString, windRule))
         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(Path2D* domPath, const float x, const float y, ExceptionState& exceptionState)
+bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const float x, const float y)
 {
-    if (!domPath) {
-        exceptionState.throwTypeError(ExceptionMessages::argumentNullOrIncorrectType(1, "Path"));
-        return false;
-    }
-
     return isPointInStrokeInternal(domPath->path(), x, y);
 }
 
 bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const float x, const float y)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return false;
     if (!state().m_invertibleCTM)
         return false;
@@ skipping 11 matching lines @@
     strokeData.setMiterLimit(miterLimit());
     strokeData.setLineDash(getLineDash(), lineDashOffset());
     return path.strokeContains(transformedPoint, strokeData);
 }
 
 void CanvasRenderingContext2D::scrollPathIntoView()
 {
     scrollPathIntoViewInternal(m_path);
 }
 
-void CanvasRenderingContext2D::scrollPathIntoView(Path2D* path2d, ExceptionState& exceptionState)
+void CanvasRenderingContext2D::scrollPathIntoView(Path2D* path2d)
 {
-    if (!path2d) {
-        exceptionState.throwTypeError(ExceptionMessages::argumentNullOrIncorrectType(1, "Path2D"));
-        return;
-    }
-
     scrollPathIntoViewInternal(path2d->path());
 }
 
 void CanvasRenderingContext2D::scrollPathIntoViewInternal(const Path& path)
 {
     if (!state().m_invertibleCTM || path.isEmpty())
         return;
 
     canvas()->document().updateLayoutIgnorePendingStylesheets();
 
@@ skipping 1204 matching lines @@
     c->setAlphaAsFloat(1.0);
     c->clearShadow();
     c->setCompositeOperation(CompositeSourceOver, blink::WebBlendModeNormal);
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore