Move SkPaint mangement for 2D canvas into CanvasRenderingContext2DState

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 1172 matching lines @@
             c->drawRect(rect, clearPaint);
             didDraw(dirtyRect);
         }
     }
 
     if (m_hitRegionManager) {
         m_hitRegionManager->removeHitRegionsInRect(rect, state().transform());
     }
 }
 
-// FIXME(crbug.com/425531): Funtional.h cannot handle override function signature.
-static void fillRectOnContext(GraphicsContext* context, const FloatRect& rect)
+static void drawRectOnCanvas(const FloatRect& rect, SkCanvas* canvas, const SkPaint* paint)

[Justin Novosad, 2015/03/19 19:45:29]

This function is significantly different from 1st patch.  Added the SkPath code
path to mimic GC behavior that is necessary for spec compliance.

 {
-    context->fillRect(rect);
-}
+    if (paint->getStyle() == SkPaint::kStroke_Style && ((rect.width() > 0) ^ (rect.height() > 0))) {

[Stephen White, 2015/03/19 20:35:17]

Suggest (A != B) instead of xor'ing bools.

[Justin Novosad, 2015/03/19 21:03:36]

Acknowledged.

+        // When stroking, we must skip the zero-dimension segments
+        SkPath path;
+        path.moveTo(rect.x(), rect.y());
+        path.lineTo(rect.maxX(), rect.maxY());
+        path.close();
+        canvas->drawPath(path, *paint);
+        return;
+    }
 
-static void strokeRectOnContext(GraphicsContext* context, const FloatRect& rect)
-{
-    context->strokeRect(rect);
+    canvas->drawRect(rect, *paint);
 }
 
 void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
-    GraphicsContext* c = drawingContext();
-    if (!c)
+    if (!drawingCanvas())
         return;
     if (!state().isTransformInvertible())
         return;
     SkIRect clipBounds;
     if (!drawingCanvas()->getClipDeviceBounds(&clipBounds))
         return;
 
     // from the HTML5 Canvas spec:
     // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing
     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
-    Gradient* gradient = c->fillGradient();
-    if (gradient && gradient->isZeroSize())
+    CanvasGradient* gradient = state().fillStyle()->canvasGradient();
+    if (gradient && gradient->gradient()->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
     if (rectContainsTransformedRect(rect, clipBounds)) {
-        checkOverdraw(rect, &c->fillPaint(), NoImage, ClipFill);
-        c->fillRect(rect);
+        const SkPaint* paint = state().getPaint(FillPaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+        checkOverdraw(rect, paint, NoImage, ClipFill);
+        drawRectOnCanvas(rect, drawingCanvas(), paint);
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(state().globalComposite())) {
-        fullCanvasCompositedDraw(bind(&fillRectOnContext, c, rect));
+        fullCanvasCompositedDraw(bind<SkCanvas*, const SkPaint*>(drawRectOnCanvas, rect), FillPaintType, DrawLooperShadowStrategy);
         didDraw(clipBounds);
     } else if (state().globalComposite() == SkXfermode::kSrc_Mode) {
         clearCanvas();
-        c->clearShadow(); // Takes care of signaling the overdraw
-        c->fillRect(rect);
-        applyShadow(DrawShadowAndForeground);
+        const SkPaint* paint = state().getPaint(FillPaintType, DrawForegroundOnly, DrawLooperShadowStrategy);
+        drawRectOnCanvas(rect, drawingCanvas(), paint);
         didDraw(clipBounds);
     } else {
         SkIRect dirtyRect;
         if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {
-            c->fillRect(rect);
+            const SkPaint* paint = state().getPaint(FillPaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+            drawRectOnCanvas(rect, drawingCanvas(), paint);
             didDraw(dirtyRect);
         }
     }
 }
 
 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!(state().lineWidth() >= 0))
         return;
 
-    GraphicsContext* c = drawingContext();
-    if (!c)
+    if (!drawingCanvas())
         return;
+
     if (!state().isTransformInvertible())
         return;
+
     SkIRect clipBounds;
     if (!drawingCanvas()->getClipDeviceBounds(&clipBounds))
         return;
 
     // If gradient size is zero, then paint nothing.
-    Gradient* gradient = c->strokeGradient();
-    if (gradient && gradient->isZeroSize())
+    CanvasGradient* gradient = state().strokeStyle()->canvasGradient();
+    if (gradient && gradient->gradient()->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
     if (isFullCanvasCompositeMode(state().globalComposite())) {
-        fullCanvasCompositedDraw(bind(&strokeRectOnContext, c, rect));
+        fullCanvasCompositedDraw(bind<SkCanvas*, const SkPaint*>(drawRectOnCanvas, rect), StrokePaintType, DrawLooperShadowStrategy);
         didDraw(clipBounds);
     } else if (state().globalComposite() == SkXfermode::kSrc_Mode) {
         clearCanvas();
-        c->clearShadow();
-        c->strokeRect(rect);
-        applyShadow(DrawShadowAndForeground);
+        const SkPaint* paint = state().getPaint(StrokePaintType, DrawForegroundOnly, DrawLooperShadowStrategy);
+        drawRectOnCanvas(rect, drawingCanvas(), paint);
         didDraw(clipBounds);
     } else {
         FloatRect boundingRect = rect;
         boundingRect.inflate(state().lineWidth() / 2);
         SkIRect dirtyRect;
         if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {
-            c->strokeRect(rect);
+            const SkPaint* paint = state().getPaint(StrokePaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+            drawRectOnCanvas(rect, drawingCanvas(), paint);
             didDraw(dirtyRect);
         }
     }
 }
 
 void CanvasRenderingContext2D::applyShadow(ShadowMode shadowMode)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
 
-    if (shouldDrawShadows()) {
+    if (state().shouldDrawShadows()) {
         c->setShadow(state().shadowOffset(), state().shadowBlur(), state().shadowColor(),
             DrawLooperBuilder::ShadowIgnoresTransforms, DrawLooperBuilder::ShadowRespectsAlpha, shadowMode);
     } else {
         c->clearShadow();
     }
 }
 
-bool CanvasRenderingContext2D::shouldDrawShadows() const
-{
-    return alphaChannel(state().shadowColor()) && (state().shadowBlur() || !state().shadowOffset().isZero());
-}
-
 static inline FloatRect normalizeRect(const FloatRect& rect)
 {
     return FloatRect(std::min(rect.x(), rect.maxX()),
         std::min(rect.y(), rect.maxY()),
         std::max(rect.width(), -rect.width()),
         std::max(rect.height(), -rect.height()));
 }
 
 static inline void clipRectsToImageRect(const FloatRect& imageRect, FloatRect* srcRect, FloatRect* dstRect)
 {
@@ skipping 172 matching lines @@
     drawingCanvas()->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const SkIRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(FloatRect(transformedRect.x(), transformedRect.y(), transformedRect.width(), transformedRect.height()));
     return state().transform().mapQuad(quad).containsQuad(transformedQuad);
 }
 
+void CanvasRenderingContext2D::fullCanvasCompositedDraw(PassOwnPtr<Function<void(SkCanvas*, const SkPaint*)>> draw, CanvasPaintType paintType, CanvasShadowStrategy shadowStrategy)

[Stephen White, 2015/03/19 20:35:16]

It looks like the shadowStrategy is always DrawLooperShadowStrategy at the call
sites. Are you going to need this later, or could you remove it?

(Actually, it looks like ImageFilterShadowStrategy isn't used/tested at all, but
I presume that'll change in a later patch.)

Thought: could we use a functor approach to hide the shadow passes and strategy
inside CanvasRenderingContext2DState itself? (Just an idea; I haven't really
thought this through.) You could express the requirements a bit more clearly
that way, as in "here's my primitive draw function" and a flag for "my primitive
might have alpha", and the state would be responsible for choosing the correct
strategy and number of passes. It would make the state more active than passive,
though.

[Justin Novosad, 2015/03/19 21:03:36]

It will be needed for drawImage
I don't see how a functor would make any of this clearer, but I could rename
some of the enums or mash them into a bitfield.

[Stephen White, 2015/03/19 22:47:54]

The idea was to hide the looper/imagefilter distinction, which is a Skia
implementation detail.

Actually maybe we could just rename the enums to PerPixelAlpha and
NoPerPixelApha, or something like that, to reflect the intent rather than the
implementation.

+{
+    ASSERT(isFullCanvasCompositeMode(state().globalComposite()));
+    ASSERT(draw);
+
+    SkCanvas* c = drawingCanvas();
+    ASSERT(c);
+
+    SkPaint layerPaint;
+    layerPaint.setXfermodeMode(state().globalComposite());
+    if (state().shouldDrawShadows()) {
+        // unroll into two independently composited passes if drawing shadows
+        c->saveLayer(0, &layerPaint);
+        SkPaint shadowPaint = *state().getPaint(paintType, DrawShadowOnly, shadowStrategy);
+        shadowPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+        (*draw)(c, &shadowPaint);
+        c->restore();
+    }
+
+    c->saveLayer(0, &layerPaint);
+    SkPaint foregroundPaint = *state().getPaint(paintType, DrawForegroundOnly, shadowStrategy);
+    foregroundPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+    (*draw)(c, &foregroundPaint);
+    c->restore();
+}
+
 void CanvasRenderingContext2D::fullCanvasCompositedDraw(PassOwnPtr<Closure> draw)
 {
     ASSERT(isFullCanvasCompositeMode(state().globalComposite()));
 
     GraphicsContext* c = drawingContext();
     ASSERT(c);
 
-    if (shouldDrawShadows()) {
+    if (state().shouldDrawShadows()) {
         // unroll into two independently composited passes if drawing shadows
         c->beginLayer(1, state().globalComposite());
         c->setCompositeOperation(SkXfermode::kSrcOver_Mode);
         applyShadow(DrawShadowOnly);
         (*draw)();
         c->setCompositeOperation(state().globalComposite());
         c->endLayer();
     }
 
     c->beginLayer(1, state().globalComposite());
@@ skipping 87 matching lines @@
         *dirtyRect = canvasIRect;
 
     return true;
 }
 
 void CanvasRenderingContext2D::didDraw(const SkIRect& dirtyRect)
 {
     if (dirtyRect.isEmpty())
         return;
 
-    if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive && shouldDrawShadows() && state().shadowBlur() > 0) {
+    if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive && state().shouldDrawShadows() && state().shadowBlur() > 0) {
         ImageBuffer* buffer = canvas()->buffer();
         if (buffer)
             buffer->setHasExpensiveOp();
     }
 
     canvas()->didDraw(SkRect::Make(dirtyRect));
 }
 
 SkCanvas* CanvasRenderingContext2D::drawingCanvas() const
 {
@@ skipping 783 matching lines @@
         if (imageType == NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink