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.

[Stephen White, 2015/03/18 22:09:34]

Is this comment still relevant?

[Justin Novosad, 2015/03/19 14:32:21]

Yes, unfortunately. because drawRect is virtual, we need this little wrapper
func.

-static void fillRectOnContext(GraphicsContext* context, const FloatRect& rect)
+static void drawRectOnCanvas(const FloatRect& rect, SkCanvas* canvas, const SkPaint* paint)
 {
-    context->fillRect(rect);
-}
-
-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().skPaint(FillPaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+        checkOverdraw(rect, paint, NoImage, ClipFill);
+        drawingCanvas()->drawRect(rect, *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().skPaint(FillPaintType, DrawForegroundOnly, DrawLooperShadowStrategy);
+        drawingCanvas()->drawRect(rect, *paint);
         didDraw(clipBounds);
     } else {
         SkIRect dirtyRect;
         if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {
-            c->fillRect(rect);
+            const SkPaint* paint = state().skPaint(FillPaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+            drawingCanvas()->drawRect(rect, *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().skPaint(StrokePaintType, DrawForegroundOnly, DrawLooperShadowStrategy);
+        drawingCanvas()->drawRect(rect, *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().skPaint(StrokePaintType, DrawShadowAndForeground, DrawLooperShadowStrategy);
+            drawingCanvas()->drawRect(rect, *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)
+{
+    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().skPaint(paintType, DrawShadowOnly, shadowStrategy);
+        shadowPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+        (*draw)(c, &shadowPaint);
+        c->restore();
+    }
+
+    c->saveLayer(0, &layerPaint);
+    SkPaint foregroundPaint = *state().skPaint(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::MakeFromIRect(dirtyRect));
 }
 
 SkCanvas* CanvasRenderingContext2D::drawingCanvas() const
 {
@@ skipping 783 matching lines @@
         if (imageType == NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink