Adding the 'filter' context attribute to 2D canvas

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 626 matching lines @@
             UseCounter::countDeprecation(canvas()->document(), UseCounter::CanvasRenderingContext2DCompositeOperationDarker);
     }
     if (!parseCompositeAndBlendOperator(operationName, op, blendMode))
         return;
     SkXfermode::Mode xfermode = WebCoreCompositeToSkiaComposite(op, blendMode);
     if (state().globalComposite() == xfermode)
         return;
     modifiableState().setGlobalComposite(xfermode);
 }
 
+String CanvasRenderingContext2D::filter() const
+{
+    return state().unparsedFilter();
+}
+
+void CanvasRenderingContext2D::setFilter(const String& filterString)
+{
+    if (filterString == state().unparsedFilter())
+        return;
+
+    RefPtrWillBeRawPtr<CSSValue> filterValue = CSSParser::parseSingleValue(CSSPropertyWebkitFilter, filterString, CSSParserContext(HTMLStandardMode, 0));
+
+    if (!filterValue || filterValue->isInitialValue() || filterValue->isInheritedValue())
+        return;
+
+    modifiableState().setUnparsedFilter(filterString);
+    modifiableState().setFilter(filterValue.release());
+}
+
 PassRefPtrWillBeRawPtr<SVGMatrixTearOff> CanvasRenderingContext2D::currentTransform() const
 {
     return SVGMatrixTearOff::create(state().transform());
 }
 
 void CanvasRenderingContext2D::setCurrentTransform(PassRefPtrWillBeRawPtr<SVGMatrixTearOff> passMatrixTearOff)
 {
     RefPtrWillBeRawPtr<SVGMatrixTearOff> matrixTearOff = passMatrixTearOff;
     const AffineTransform& transform = matrixTearOff->value();
     setTransform(transform.a(), transform.b(), transform.c(), transform.d(), transform.e(), transform.f());
@@ skipping 151 matching lines @@
 
 static bool isFullCanvasCompositeMode(SkXfermode::Mode op)
 {
     // See 4.8.11.1.3 Compositing
     // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
     // implement the specification's behavior.
     return op == SkXfermode::kSrcIn_Mode || op == SkXfermode::kSrcOut_Mode || op == SkXfermode::kDstIn_Mode || op == SkXfermode::kDstATop_Mode;
 }
 
 template<typename DrawFunc>
-void CanvasRenderingContext2D::fullCanvasCompositedDraw(const DrawFunc& drawFunc, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
+void CanvasRenderingContext2D::compositedDraw(const DrawFunc& drawFunc, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
 {
-    ASSERT(isFullCanvasCompositeMode(state().globalComposite()));
+    SkImageFilter* filter = state().filter(canvas(), accessFont());
+    ASSERT(isFullCanvasCompositeMode(state().globalComposite()) || filter);
     ASSERT(drawingCanvas());
-
-    SkPaint layerPaint;
-    layerPaint.setXfermodeMode(state().globalComposite());
+    SkMatrix ctm = drawingCanvas()->getTotalMatrix();
+    drawingCanvas()->resetMatrix();
+    SkPaint compositePaint;
+    compositePaint.setXfermodeMode(state().globalComposite());
     if (state().shouldDrawShadows()) {
         // unroll into two independently composited passes if drawing shadows
-        drawingCanvas()->saveLayer(nullptr, &layerPaint);
         SkPaint shadowPaint = *state().getPaint(paintType, DrawShadowOnly, imageType);
-        shadowPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
-        drawFunc(&shadowPaint);
+        int saveCount = drawingCanvas()->getSaveCount();
+        if (filter) {
+            SkPaint filterPaint;
+            filterPaint.setImageFilter(filter);
+            // TODO(junov): crbug.com/502921 We could use primitive bounds if we knew that the filter

[Stephen White, 2015/06/22 15:28:54]

There's actually a traversal to determine the minimum paint rect in the
FilterEffect DAG. The entry point is FilterEffect::determineAbsolutePaintRect(),
IIRC. It uses the virtuals mapPaintRect() and affectsTransparentPixels(). At
some point we should move it to Skia. But maybe you could use
affectsTransparentPixels() for your purposes, at a minimum.

+            // does not affect transparent black regions.
+            drawingCanvas()->saveLayer(nullptr, &shadowPaint);
+            drawingCanvas()->saveLayer(nullptr, &filterPaint);
+            SkPaint foregroundPaint = *state().getPaint(paintType, DrawForegroundOnly, imageType);
+            drawingCanvas()->setMatrix(ctm);
+            drawFunc(&foregroundPaint);
+        } else {
+            ASSERT(isFullCanvasCompositeMode(state().globalComposite()));
+            drawingCanvas()->saveLayer(nullptr, &compositePaint);
+            shadowPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+            drawingCanvas()->setMatrix(ctm);
+            drawFunc(&shadowPaint);
+        }
         if (!drawingCanvas())
             return;
-        drawingCanvas()->restore();
+        drawingCanvas()->restoreToCount(saveCount);
     }
 
-    drawingCanvas()->saveLayer(nullptr, &layerPaint);
+    compositePaint.setImageFilter(filter);
+    // TODO(junov): crbug.com/502921 We could use primitive bounds if we knew that the filter
+    // does not affect transparent black regions *and* !isFullCanvasCompositeMode
+    drawingCanvas()->saveLayer(nullptr, &compositePaint);
     SkPaint foregroundPaint = *state().getPaint(paintType, DrawForegroundOnly, imageType);
     foregroundPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+    drawingCanvas()->setMatrix(ctm);
     drawFunc(&foregroundPaint);
     if (!drawingCanvas())
         return;
     drawingCanvas()->restore();
+    drawingCanvas()->setMatrix(ctm);
 }
 
 template<typename DrawFunc, typename ContainsFunc>
 bool CanvasRenderingContext2D::draw(const DrawFunc& drawFunc, const ContainsFunc& drawCoversClipBounds, const SkRect& bounds, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
 {
     if (!state().isTransformInvertible())
         return false;
 
     SkIRect clipBounds;
     if (!drawingCanvas() || !drawingCanvas()->getClipDeviceBounds(&clipBounds))
         return false;
 
     // If gradient size is zero, then paint nothing.
     CanvasStyle* style = state().style(paintType);
     if (style) {
         CanvasGradient* gradient = style->canvasGradient();
         if (gradient && gradient->gradient()->isZeroSize())
             return false;
     }
 
-    if (isFullCanvasCompositeMode(state().globalComposite())) {
-        fullCanvasCompositedDraw(drawFunc, paintType, imageType);
+    if (isFullCanvasCompositeMode(state().globalComposite()) || state().filter(canvas(), accessFont())) {
+        compositedDraw(drawFunc, paintType, imageType);
         didDraw(clipBounds);
     } else if (state().globalComposite() == SkXfermode::kSrc_Mode) {
         clearCanvas(); // takes care of checkOvewrdraw()
         const SkPaint* paint = state().getPaint(paintType, DrawForegroundOnly, imageType);
         drawFunc(paint);
         didDraw(clipBounds);
     } else {
         SkIRect dirtyRect;
         if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
             const SkPaint* paint = state().getPaint(paintType, DrawShadowAndForeground, imageType);
@@ skipping 1362 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink