globalCompositeOperation is ignored in stroke, strokeRect.

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 211 matching lines @@
 }
 
 // Important: Several of these properties are also stored in GraphicsContext's
 // StrokeData. The default values that StrokeData uses may not the same values
 // that the canvas 2d spec specifies. Make sure to sync the initial state of the
 // GraphicsContext in HTMLCanvasElement::createImageBuffer()!
 CanvasRenderingContext2D::State::State()
     : m_unrealizedSaveCount(0)
     , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_fillStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_lineWidth(1)

[Justin Novosad, 2014/04/07 18:03:14]

You responded "Done", but m_lineWidth is still here. That is okay. I take back
my earlier comment. m_lineWidth is still useful for retaining state when there
is no drawingContext.

     , m_lineCap(ButtCap)
     , m_lineJoin(MiterJoin)
     , m_miterLimit(10)
     , m_shadowBlur(0)
     , m_shadowColor(Color::transparent)
     , m_globalAlpha(1)
     , m_globalComposite(CompositeSourceOver)
     , m_globalBlend(blink::WebBlendModeNormal)
     , m_invertibleCTM(true)
     , m_lineDashOffset(0)
@@ skipping 764 matching lines @@
     }
 
     WindRule windRule = c->fillRule();
     WindRule newWindRule = RULE_NONZERO;
     if (!parseWinding(windingRuleString, newWindRule)) {
         return;
     }
     c->setFillRule(newWindRule);
 
     if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedFill(path);
+        fullCanvasComposite(path, &GraphicsContext::fillPath);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->fillPath(path);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {
             c->fillPath(path);
             didDraw(dirtyRect);
@@ skipping 28 matching lines @@
     if (path.isEmpty()) {
         return;
     }
     GraphicsContext* c = drawingContext();
     if (!c) {
         return;
     }
     if (!state().m_invertibleCTM) {
         return;
     }
+    FloatRect clipBounds;
+    if (!c->getTransformedClipBounds(&clipBounds))
+        return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->strokeGradient();
     if (gradient && gradient->isZeroSize()) {
         return;
     }
 
-    FloatRect bounds = path.boundingRect();
-    inflateStrokeRect(bounds);
-    FloatRect dirtyRect;
-    if (computeDirtyRect(bounds, &dirtyRect)) {
+    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
+        fullCanvasComposite(path, &GraphicsContext::strokePath);
+        didDraw(clipBounds);
+    } else if (state().m_globalComposite == CompositeCopy) {
+        clearCanvas();
         c->strokePath(path);
-        didDraw(dirtyRect);
+        didDraw(clipBounds);
+    } else {
+        FloatRect bounds = path.boundingRect();
+        inflateStrokeRect(bounds);
+        FloatRect dirtyRect;
+        if (computeDirtyRect(path.boundingRect(), &dirtyRect)) {
+            c->strokePath(path);
+            didDraw(dirtyRect);
+        }
     }
 }
 
 void CanvasRenderingContext2D::stroke()
 {
     strokeInternal(m_path);
 }
 
 void CanvasRenderingContext2D::stroke(Path2D* domPath, ExceptionState& exceptionState)
 {
@@ skipping 228 matching lines @@
     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
     if (rectContainsTransformedRect(rect, clipBounds)) {
         c->fillRect(rect);
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedFill(rect);
+        fullCanvasComposite(rect, &GraphicsContext::fillRect);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->fillRect(rect);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {
             c->fillRect(rect);
             didDraw(dirtyRect);
         }
     }
 }
 
 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!(state().m_lineWidth >= 0))
         return;
 
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
+    FloatRect clipBounds;
+    if (!c->getTransformedClipBounds(&clipBounds))
+        return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->strokeGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
 
-    FloatRect boundingRect = rect;
-    boundingRect.inflate(state().m_lineWidth / 2);
-    FloatRect dirtyRect;
-    if (computeDirtyRect(boundingRect, &dirtyRect)) {
-        c->strokeRect(rect, state().m_lineWidth);
-        didDraw(dirtyRect);
+    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
+        fullCanvasComposite(rect, &GraphicsContext::strokeRect);
+        didDraw(clipBounds);
+    } else if (state().m_globalComposite == CompositeCopy) {
+        clearCanvas();
+        c->strokeRect(rect);
+        didDraw(clipBounds);
+    } else {
+        FloatRect boundingRect = rect;
+        FloatRect dirtyRect;
+        if (computeDirtyRect(boundingRect, &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)
 {
@@ skipping 268 matching lines @@
 
 template<class T> void  CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
 {
     ASSERT(isFullCanvasCompositeMode(op));
 
     drawingContext()->beginLayer(1, op);
     drawImageToContext(image, drawingContext(), dest, src, CompositeSourceOver);
     drawingContext()->endLayer();
 }
 
-static void fillPrimitive(const FloatRect& rect, GraphicsContext* context)
-{
-    context->fillRect(rect);
-}
-
-static void fillPrimitive(const Path& path, GraphicsContext* context)
-{
-    context->fillPath(path);
-}
-
-template<class T> void CanvasRenderingContext2D::fullCanvasCompositedFill(const T& area)
+template<class T> void CanvasRenderingContext2D::fullCanvasComposite(const T& area, void (GraphicsContext::*drawOperation)(const T&))

[Justin Novosad, 2014/04/07 18:03:14]

drawOperation is an unnecessary indirection.  A simple template specialization
would suffice. like this:

template<typename T> void fill(GraphicsContext*, const T&)
{
    ASSERT_NOT_REACHED();
}

template<> void fill<FloatRect>(GraphicsContext* c, const FloatRect& rect)
{
    c->fillRect(rect);
}

 {
     ASSERT(isFullCanvasCompositeMode(state().m_globalComposite));
 
     GraphicsContext* c = drawingContext();
     ASSERT(c);
     c->beginLayer(1, state().m_globalComposite);
     CompositeOperator previousOperator = c->compositeOperation();
     c->setCompositeOperation(CompositeSourceOver);
-    fillPrimitive(area, c);
+    (c->*drawOperation)(area);
     c->setCompositeOperation(previousOperator);
     c->endLayer();
 }
 
 PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1, ExceptionState& exceptionState)
 {
     if (!std::isfinite(x0))
         exceptionState.throwDOMException(NotSupportedError, ExceptionMessages::notAFiniteNumber(x0, "x0"));
     else if (!std::isfinite(y0))
         exceptionState.throwDOMException(NotSupportedError, ExceptionMessages::notAFiniteNumber(y0, "y0"));
@@ skipping 754 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