Fix layer hoisting image filter corner cases

src/core/SkRecordDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
@@ skipping 590 matching lines @@
     }
 
     template <typename T> void operator()(const T& op) {
         fFillBounds(op);
         this->trackSaveLayers(op);
     }
 
 private:
     struct SaveLayerInfo {
         SaveLayerInfo() { }
-        SaveLayerInfo(int opIndex, bool isSaveLayer, const SkPaint* paint)
+        SaveLayerInfo(int opIndex, bool isSaveLayer, const SkRect* bounds, const SkPaint* paint)
             : fStartIndex(opIndex)
             , fIsSaveLayer(isSaveLayer)
             , fHasNestedSaveLayer(false)
+            , fBounds(bounds ? *bounds : SkRect::MakeEmpty())
             , fPaint(paint) {
         }
 
         int                fStartIndex;
         bool               fIsSaveLayer;
         bool               fHasNestedSaveLayer;
+        SkRect             fBounds;
         const SkPaint*     fPaint;
     };
 
     template <typename T> void trackSaveLayers(const T& op) {
         /* most ops aren't involved in saveLayers */
     }
-    void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL); }
-    void trackSaveLayers(const SaveLayer& sl) { this->pushSaveLayerInfo(true, sl.paint); }
+    void trackSaveLayers(const Save& s) { this->pushSaveLayerInfo(false, NULL, NULL); }
+    void trackSaveLayers(const SaveLayer& sl) { this->pushSaveLayerInfo(true, sl.bounds, sl.paint); }
     void trackSaveLayers(const Restore& r) { this->popSaveLayerInfo(); }
 
     void trackSaveLayersForPicture(const SkPicture* picture, const SkPaint* paint) {
         // For sub-pictures, we wrap their layer information within the parent
         // picture's rendering hierarchy
         SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
 
         const SkLayerInfo* childData =
             static_cast<const SkLayerInfo*>(picture->EXPERIMENTAL_getAccelData(key));
         if (!childData) {
@@ skipping 16 matching lines @@
 
             this->updateStackForSaveLayer();
 
             SkLayerInfo::BlockInfo& dst = fAccelData->addBlock();
 
             // If src.fPicture is NULL the layer is in dp.picture; otherwise
             // it belongs to a sub-picture.
             dst.fPicture = src.fPicture ? src.fPicture : picture;
             dst.fPicture->ref();
             dst.fBounds = newBound;
+            dst.fSrcBounds = src.fSrcBounds;
             dst.fLocalMat = src.fLocalMat;
             dst.fPreMat = src.fPreMat;
             dst.fPreMat.postConcat(fFillBounds.ctm());
             if (src.fPaint) {
                 dst.fPaint = SkNEW_ARGS(SkPaint, (*src.fPaint));
             }
             dst.fSaveLayerOpID = src.fSaveLayerOpID;
             dst.fRestoreOpID = src.fRestoreOpID;
             dst.fHasNestedLayers = src.fHasNestedLayers;
             dst.fIsNested = fSaveLayersInStack > 0 || src.fIsNested;
@@ skipping 25 matching lines @@
             if (fSaveLayerStack[index].fHasNestedSaveLayer) {
                 break;
             }
             fSaveLayerStack[index].fHasNestedSaveLayer = true;
             if (fSaveLayerStack[index].fIsSaveLayer) {
                 break;
             }
         }
     }
 
-    void pushSaveLayerInfo(bool isSaveLayer, const SkPaint* paint) {
+    void pushSaveLayerInfo(bool isSaveLayer, const SkRect* bounds, const SkPaint* paint) {
         if (isSaveLayer) {
             this->updateStackForSaveLayer();
             ++fSaveLayersInStack;
             fSaveLayerOpStack.push(fFillBounds.currentOp());
         }
 
-        fSaveLayerStack.push(SaveLayerInfo(fFillBounds.currentOp(), isSaveLayer, paint));
+        fSaveLayerStack.push(SaveLayerInfo(fFillBounds.currentOp(), isSaveLayer, bounds, paint));
     }
 
     void popSaveLayerInfo() {
         if (fSaveLayerStack.count() <= 0) {
             SkASSERT(false);
             return;
         }
 
         SkASSERT(fSaveLayersInStack == fSaveLayerOpStack.count());
 
         SaveLayerInfo sli;
         fSaveLayerStack.pop(&sli);
 
         if (!sli.fIsSaveLayer) {
             return;
         }
 
         --fSaveLayersInStack;
 
         SkLayerInfo::BlockInfo& block = fAccelData->addBlock();
 
         SkASSERT(NULL == block.fPicture);  // This layer is in the top-most picture
 
         block.fBounds = fFillBounds.getBounds(sli.fStartIndex);
         block.fLocalMat = fFillBounds.ctm();
         block.fPreMat = SkMatrix::I();
         if (sli.fPaint) {
             block.fPaint = SkNEW_ARGS(SkPaint, (*sli.fPaint));
         }
+
+        block.fSrcBounds = sli.fBounds;
         block.fSaveLayerOpID = sli.fStartIndex;
         block.fRestoreOpID = fFillBounds.currentOp();
         block.fHasNestedLayers = sli.fHasNestedSaveLayer;
         block.fIsNested = fSaveLayersInStack > 0;
 
         block.fKeySize = fSaveLayerOpStack.count();
         block.fKey = SkNEW_ARRAY(unsigned, block.fKeySize);
         memcpy(block.fKey, fSaveLayerOpStack.begin(), block.fKeySize * sizeof(unsigned));
 
         fSaveLayerOpStack.pop();
@@ skipping 29 matching lines @@
     SkRecords::CollectLayers visitor(cullRect, record, pictList, data);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }