Use IDL union types for CanvasRenderingContext2D.{fill,stroke}Style

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 416 matching lines @@
         return;
     m_path.transform(state().m_transform);
     m_stateStack.removeLast();
     m_path.transform(state().m_transform.inverse());
     GraphicsContext* c = drawingContext();
     if (c)
         c->restore();
     validateStateStack();
 }
 
-CanvasStyle* CanvasRenderingContext2D::strokeStyle() const
+static inline void convertCanvasStyleToUnionType(CanvasStyle* style, StringOrCanvasGradientOrCanvasPattern& returnValue)
 {
-    return state().m_strokeStyle.get();
+    if (CanvasGradient* gradient = style->canvasGradient()) {
+        returnValue.setCanvasGradient(gradient);
+        return;
+    }
+    if (CanvasPattern* pattern = style->canvasPattern()) {
+        returnValue.setCanvasPattern(pattern);
+        return;
+    }
+    returnValue.setString(style->color());
 }
 
-void CanvasRenderingContext2D::setStrokeStyle(PassRefPtrWillBeRawPtr<CanvasStyle> prpStyle)
+void CanvasRenderingContext2D::strokeStyle(StringOrCanvasGradientOrCanvasPattern& returnValue) const
 {
-    RefPtrWillBeRawPtr<CanvasStyle> style = prpStyle;
+    convertCanvasStyleToUnionType(state().m_strokeStyle.get(), returnValue);
+}
 
-    if (!style)
-        return;
+void CanvasRenderingContext2D::setStrokeStyle(const StringOrCanvasGradientOrCanvasPattern& style)
+{
+    ASSERT(!style.isNull());
 
-    if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentColor(*style))
-        return;
+    String colorString;
+    RefPtrWillBeRawPtr<CanvasStyle> canvasStyle;
+    if (style.isString()) {
+        colorString = style.getAsString();
+        if (colorString == state().m_unparsedStrokeColor)

[fs, 2014/11/24 13:20:24]

The removal of the legacy APIs seems to have dropped this optimization, but left
the state-field, so I recovered it. If it was intentional to remove it, then I
can drop this (and the state-field).

[Justin Novosad, 2014/11/24 15:41:02]

Thanks for catching that. the removal was unintentional.

+            return;
+        RGBA32 parsedColor = 0;
+        if (!parseColorOrCurrentColor(parsedColor, colorString, canvas()))
+            return;
+        if (state().m_strokeStyle->isEquivalentRGBA(parsedColor)) {
+            realizeSaves(nullptr);
+            modifiableState().m_unparsedStrokeColor = colorString;
+            return;
+        }
+        canvasStyle = CanvasStyle::createFromRGBA(parsedColor);
+    } else if (style.isCanvasGradient()) {
+        canvasStyle = CanvasStyle::createFromGradient(style.getAsCanvasGradient());
+    } else if (style.isCanvasPattern()) {
+        RefPtrWillBeRawPtr<CanvasPattern> canvasPattern = style.getAsCanvasPattern();
 
-    if (style->isCurrentColor()) {
-        if (style->hasOverrideAlpha())
-            style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));
-        else
-            style = CanvasStyle::createFromRGBA(currentColor(canvas()));
-    } else if (canvas()->originClean() && style->canvasPattern() && !style->canvasPattern()->originClean()) {
-        canvas()->setOriginTainted();
+        if (canvas()->originClean() && !canvasPattern->originClean())
+            canvas()->setOriginTainted();
+
+        canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
+    ASSERT(canvasStyle);
+
     GraphicsContext* c = drawingContext();
     realizeSaves(c);
-    modifiableState().m_strokeStyle = style.release();
+    modifiableState().m_strokeStyle = canvasStyle.release();
     if (!c)
         return;
     state().m_strokeStyle->applyStrokeColor(c);
-    modifiableState().m_unparsedStrokeColor = String();
+    modifiableState().m_unparsedStrokeColor = colorString;
 }
 
-CanvasStyle* CanvasRenderingContext2D::fillStyle() const
+void CanvasRenderingContext2D::fillStyle(StringOrCanvasGradientOrCanvasPattern& returnValue) const
 {
-    return state().m_fillStyle.get();
+    convertCanvasStyleToUnionType(state().m_fillStyle.get(), returnValue);
 }
 
-void CanvasRenderingContext2D::setFillStyle(PassRefPtrWillBeRawPtr<CanvasStyle> prpStyle)
+void CanvasRenderingContext2D::setFillStyle(const StringOrCanvasGradientOrCanvasPattern& style)
 {
-    RefPtrWillBeRawPtr<CanvasStyle> style = prpStyle;
+    ASSERT(!style.isNull());
 
-    if (!style)
-        return;
+    String colorString;
+    RefPtrWillBeRawPtr<CanvasStyle> canvasStyle;
+    if (style.isString()) {
+        colorString = style.getAsString();
+        if (colorString == state().m_unparsedFillColor)
+            return;
+        RGBA32 parsedColor = 0;
+        if (!parseColorOrCurrentColor(parsedColor, colorString, canvas()))
+            return;
+        if (state().m_fillStyle->isEquivalentRGBA(parsedColor)) {
+            realizeSaves(nullptr);
+            modifiableState().m_unparsedFillColor = colorString;
+            return;
+        }
+        canvasStyle = CanvasStyle::createFromRGBA(parsedColor);
+    } else if (style.isCanvasGradient()) {
+        canvasStyle = CanvasStyle::createFromGradient(style.getAsCanvasGradient());
+    } else if (style.isCanvasPattern()) {
+        RefPtrWillBeRawPtr<CanvasPattern> canvasPattern = style.getAsCanvasPattern();
 
-    if (state().m_fillStyle && state().m_fillStyle->isEquivalentColor(*style))
-        return;
+        if (canvas()->originClean() && !canvasPattern->originClean())
+            canvas()->setOriginTainted();
 
-    if (style->isCurrentColor()) {
-        if (style->hasOverrideAlpha())
-            style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));
-        else
-            style = CanvasStyle::createFromRGBA(currentColor(canvas()));
-    } else if (canvas()->originClean() && style->canvasPattern() && !style->canvasPattern()->originClean()) {
-        canvas()->setOriginTainted();
+        canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
+    ASSERT(canvasStyle);
+
     GraphicsContext* c = drawingContext();
     realizeSaves(c);
-    modifiableState().m_fillStyle = style.release();
+    modifiableState().m_fillStyle = canvasStyle.release();
     if (!c)
         return;
     state().m_fillStyle->applyFillColor(c);
-    modifiableState().m_unparsedFillColor = String();
+    modifiableState().m_unparsedFillColor = colorString;
 }
 
 float CanvasRenderingContext2D::lineWidth() const
 {
     return state().m_lineWidth;
 }
 
 void CanvasRenderingContext2D::setLineWidth(float width)
 {
     if (!std::isfinite(width) || width <= 0)
@@ skipping 1816 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink