Simplify CRC2D winding rule handling

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 946 matching lines @@
 }
 
 static bool isFullCanvasCompositeMode(CompositeOperator op)
 {
     // See 4.8.11.1.3 Compositing
     // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
     // implement the specification's behavior.
     return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop;
 }
 
-static bool parseWinding(const String& windingRuleString, WindRule& windRule)
+static WindRule parseWinding(const String& windingRuleString)
 {
     if (windingRuleString == "nonzero")
-        windRule = RULE_NONZERO;
-    else if (windingRuleString == "evenodd")
-        windRule = RULE_EVENODD;
-    else
-        return false;
+        return RULE_NONZERO;
+    if (windingRuleString == "evenodd")
+        return RULE_EVENODD;
 
-    return true;
+    ASSERT_NOT_REACHED();
+    return RULE_EVENODD;
 }
 
 void CanvasRenderingContext2D::fillInternal(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;
     }
 
     WindRule windRule = c->fillRule();
-    WindRule newWindRule = RULE_NONZERO;
-    if (!parseWinding(windingRuleString, newWindRule)) {
-        return;
-    }
-    c->setFillRule(newWindRule);
+    c->setFillRule(parseWinding(windingRuleString));
 
     if (isFullCanvasCompositeMode(state().m_globalComposite)) {
         fullCanvasCompositedFill(path);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->fillPath(path);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
@@ skipping 72 matching lines @@
 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);
+    c->canvasClip(path, parseWinding(windingRuleString));
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
 void CanvasRenderingContext2D::clip(Path2D* domPath, ExceptionState& exceptionState)
 {
     clip(domPath, "nonzero", exceptionState);
@@ skipping 36 matching lines @@
         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);
+    return path.contains(transformedPoint, parseWinding(windingRuleString));
 }
 
 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)
 {
     if (!domPath) {
@@ skipping 1256 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