apply xfermode after imagefilter when we create a tmp layer

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
@@ skipping 290 matching lines @@
 
 class AutoDrawLooper {
 public:
     AutoDrawLooper(SkCanvas* canvas, const SkSurfaceProps& props, const SkPaint& paint,
                    bool skipLayerForImageFilter = false,
                    const SkRect* bounds = NULL) : fOrigPaint(paint) {
         fCanvas = canvas;
         fFilter = canvas->getDrawFilter();
         fPaint = &fOrigPaint;
         fSaveCount = canvas->getSaveCount();
-        fDoClearImageFilter = false;
+        fTempLayerForImageFilter = false;
         fDone = false;
 
         if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
+            /**
+             *  We implement ImageFilters for a given draw by creating a layer, then applying the
+             *  imagefilter to the pixels of that layer (its backing surface/image), and then
+             *  we call restore() to apply that layer to the main canvas.
+             *
+             *  To generate the src pixels for the filter, we remove the imagefilter and the
+             *  xfermode from the paint that we (AutoDrawLooper) return (fPaint). The imagefilter
+             *  is applied right before the restore, and the xfermode is applied during the restore.

[Stephen White, 2015/04/20 14:36:46]

Nit: this might be slightly misleading: the imagefilter is also applied *during*
restore() (the function), although 
you're correct that it's applied before restore() draws the (filtered) layer to
the canvas.

Maybe something like: "during restore(), the imagefilter is applied, and then
the filtered result is drawn to the main canvas with the xfermode applied".

[reed1, 2015/04/20 14:49:19]

Done.

+             *
+             *  We strip the imagefilter/xfermode inside doNext().
+             */
             SkPaint tmp;
+            // store the imagefilter/xfermode on the layer's paint, so they can be applied in
+            // restore.
             tmp.setImageFilter(fOrigPaint.getImageFilter());
+            tmp.setXfermode(fOrigPaint.getXfermode());
             (void)canvas->internalSaveLayer(bounds, &tmp, SkCanvas::kARGB_ClipLayer_SaveFlag,
                                             SkCanvas::kFullLayer_SaveLayerStrategy);
-            // we'll clear the imageFilter for the actual draws in next(), so
-            // it will only be applied during the restore().
-            fDoClearImageFilter = true;
+            fTempLayerForImageFilter = true;

[Stephen White, 2015/04/20 14:36:46]

This name is much clearer to me; thanks for that!

         }
 
         if (SkDrawLooper* looper = paint.getLooper()) {
             void* buffer = fLooperContextAllocator.reserveT<SkDrawLooper::Context>(
                     looper->contextSize());
             fLooperContext = looper->createContext(canvas, buffer);
             fIsSimple = false;
         } else {
             fLooperContext = NULL;
             // can we be marked as simple?
-            fIsSimple = !fFilter && !fDoClearImageFilter;
+            fIsSimple = !fFilter && !fTempLayerForImageFilter;
         }
 
         uint32_t oldFlags = paint.getFlags();
         fNewPaintFlags = filter_paint_flags(props, oldFlags);
         if (fIsSimple && (fNewPaintFlags != oldFlags)) {
             SkPaint* paint = fLazyPaint.set(fOrigPaint);
             paint->setFlags(fNewPaintFlags);
             fPaint = paint;
             // if we're not simple, doNext() will take care of calling setFlags()
         }
     }
 
     ~AutoDrawLooper() {
-        if (fDoClearImageFilter) {
+        if (fTempLayerForImageFilter) {
             fCanvas->internalRestore();
         }
         SkASSERT(fCanvas->getSaveCount() == fSaveCount);
     }
 
     const SkPaint& paint() const {
         SkASSERT(fPaint);
         return *fPaint;
     }
 
     bool next(SkDrawFilter::Type drawType) {
         if (fDone) {
             return false;
         } else if (fIsSimple) {
             fDone = true;
             return !fPaint->nothingToDraw();
         } else {
             return this->doNext(drawType);
         }
     }
 
 private:
     SkLazyPaint     fLazyPaint;
     SkCanvas*       fCanvas;
     const SkPaint&  fOrigPaint;
     SkDrawFilter*   fFilter;
     const SkPaint*  fPaint;
     int             fSaveCount;
     uint32_t        fNewPaintFlags;
-    bool            fDoClearImageFilter;
+    bool            fTempLayerForImageFilter;
     bool            fDone;
     bool            fIsSimple;
     SkDrawLooper::Context* fLooperContext;
     SkSmallAllocator<1, 32> fLooperContextAllocator;
 
     bool doNext(SkDrawFilter::Type drawType);
 };
 
 bool AutoDrawLooper::doNext(SkDrawFilter::Type drawType) {
     fPaint = NULL;
     SkASSERT(!fIsSimple);
-    SkASSERT(fLooperContext || fFilter || fDoClearImageFilter);
+    SkASSERT(fLooperContext || fFilter || fTempLayerForImageFilter);
 
     SkPaint* paint = fLazyPaint.set(fOrigPaint);
     paint->setFlags(fNewPaintFlags);
 
-    if (fDoClearImageFilter) {
+    if (fTempLayerForImageFilter) {
         paint->setImageFilter(NULL);
+        paint->setXfermode(NULL);
     }
 
     if (fLooperContext && !fLooperContext->next(fCanvas, paint)) {
         fDone = true;
         return false;
     }
     if (fFilter) {
         if (!fFilter->filter(paint, drawType)) {
             fDone = true;
             return false;
@@ skipping 2155 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }