IDL: make optional arguments (without default) explicit sometimes

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 844 matching lines @@
     if (!c)
         return;
 
     if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy))
         return;
 
     resetTransform();
     transform(m11, m12, m21, m22, dx, dy);
 }
 
-void CanvasRenderingContext2D::setStrokeColor(const String& color)
+void CanvasRenderingContext2D::setStrokeColor(const String& color, Optional<float> alpha)
 {
+    if (!alpha.isMissing()) {
+        setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));
+        return;
+    }
     if (color == state().m_unparsedStrokeColor)
         return;
     realizeSaves();
     setStrokeStyle(CanvasStyle::createFromString(color));
     modifiableState().m_unparsedStrokeColor = color;
 }
 
-void CanvasRenderingContext2D::setStrokeColor(float grayLevel)
-{
-    if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))
-        return;
-    setStrokeStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));
-}
-
-void CanvasRenderingContext2D::setStrokeColor(const String& color, float alpha)
-{
-    setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));
-}
-
 void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)
 {
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
         return;
     setStrokeStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, alpha));
 }
 
 void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)
 {
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(r, g, b, a))
         return;
     setStrokeStyle(CanvasStyle::createFromRGBAChannels(r, g, b, a));
 }
 
 void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)
 {
     if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentCMYKA(c, m, y, k, a))
         return;
     setStrokeStyle(CanvasStyle::createFromCMYKAChannels(c, m, y, k, a));
 }
 
-void CanvasRenderingContext2D::setFillColor(const String& color)
+void CanvasRenderingContext2D::setFillColor(const String& color, Optional<float> alpha)
 {
+    if (!alpha.isMissing()) {
+        setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));
+        return;
+    }
     if (color == state().m_unparsedFillColor)
         return;
     realizeSaves();
     setFillStyle(CanvasStyle::createFromString(color));
     modifiableState().m_unparsedFillColor = color;
 }
 
-void CanvasRenderingContext2D::setFillColor(float grayLevel)
-{
-    if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))
-        return;
-    setFillStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));
-}
-
-void CanvasRenderingContext2D::setFillColor(const String& color, float alpha)
-{
-    setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));
-}
-
 void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)
 {
     if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
         return;
     setFillStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, alpha));
 }
 
 void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)
 {
     if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(r, g, b, a))
@@ skipping 235 matching lines @@
 
     StrokeData strokeData;
     strokeData.setThickness(lineWidth());
     strokeData.setLineCap(getLineCap());
     strokeData.setLineJoin(getLineJoin());
     strokeData.setMiterLimit(miterLimit());
     strokeData.setLineDash(getLineDash(), lineDashOffset());
     return path.strokeContains(transformedPoint, strokeData);
 }
 
-void CanvasRenderingContext2D::scrollPathIntoView()
-{
-    scrollPathIntoViewInternal(m_path);
-}
-
 void CanvasRenderingContext2D::scrollPathIntoView(Path2D* path2d)
 {
-    scrollPathIntoViewInternal(path2d->path());
+    scrollPathIntoViewInternal(path2d ? path2d->path() : m_path);
 }
 
 void CanvasRenderingContext2D::scrollPathIntoViewInternal(const Path& path)
 {
     RenderObject* renderer = canvas()->renderer();
     RenderBox* renderBox = canvas()->renderBox();
     if (!renderer || !renderBox || !state().m_invertibleCTM || path.isEmpty())
         return;
 
     canvas()->document().updateLayoutIgnorePendingStylesheets();
@@ skipping 136 matching lines @@
         FloatRect boundingRect = rect;
         boundingRect.inflate(state().m_lineWidth / 2);
         FloatRect dirtyRect;
         if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {
             c->strokeRect(rect);
             didDraw(dirtyRect);
         }
     }
 }
 
-void CanvasRenderingContext2D::setShadow(float width, float height, float blur)
-{
-    setShadow(FloatSize(width, height), blur, Color::transparent);
-}
-
-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color)
+void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const Optional<String>& color, Optional<float> alpha)
 {
     RGBA32 rgba;
-    if (!parseColorOrCurrentColor(rgba, color, canvas()))
+    if (color.isMissing())
+        rgba = Color::transparent;
+    else if (!parseColorOrCurrentColor(rgba, color, canvas()))
         return;
+    if (!alpha.isMissing())
+        rgba = colorWithOverrideAlpha(rgba, alpha);
     setShadow(FloatSize(width, height), blur, rgba);
 }
 
-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel)
-{
-    setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, 1));
-}
-
-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color, float alpha)
-{
-    RGBA32 rgba;
-    if (!parseColorOrCurrentColor(rgba, color, canvas()))
-        return;
-    setShadow(FloatSize(width, height), blur, colorWithOverrideAlpha(rgba, alpha));
-}
-
 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)
 {
     setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, alpha));
 }
 
 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)
 {
     setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(r, g, b, a));
 }
 
@@ skipping 626 matching lines @@
 {
     TextBaseline baseline;
     if (!parseTextBaseline(s, baseline))
         return;
     if (state().m_textBaseline == baseline)
         return;
     realizeSaves();
     modifiableState().m_textBaseline = baseline;
 }
 
-void CanvasRenderingContext2D::fillText(const String& text, float x, float y)
+void CanvasRenderingContext2D::fillText(const String& text, float x, float y, Optional<float> maxWidth)
 {
-    drawTextInternal(text, x, y, true);
+    drawTextInternal(text, x, y, true, maxWidth.get(), !maxWidth.isMissing());
 }
 
-void CanvasRenderingContext2D::fillText(const String& text, float x, float y, float maxWidth)
+void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, Optional<float> maxWidth)
 {
-    drawTextInternal(text, x, y, true, maxWidth, true);
-}
-
-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y)
-{
-    drawTextInternal(text, x, y, false);
-}
-
-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, float maxWidth)
-{
-    drawTextInternal(text, x, y, false, maxWidth, true);
+    drawTextInternal(text, x, y, false, maxWidth.get(), !maxWidth.isMissing());
 }
 
 static inline bool isSpaceCharacter(UChar c)
 {
     // According to specification all space characters should be replaced with 0x0020 space character.
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#text-preparation-algorithm
     // The space characters according to specification are : U+0020, U+0009, U+000A, U+000C, and U+000D.
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#space-character
     // This function returns true for 0x000B also, so that this is backward compatible.
     // Otherwise, the test LayoutTests/canvas/philip/tests/2d.text.draw.space.collapse.space.html will fail
@@ skipping 397 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink