Apply the layer's image filter to the hoisted image

src/gpu/GrLayerCache.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
 #include "GrAtlas.h"
 #include "GrRect.h"
 
 #include "SkChecksum.h"
+#include "SkImageFilter.h"
 #include "SkMessageBus.h"
 #include "SkPicture.h"
 #include "SkTDynamicHash.h"
 
 // Set to 0 to disable caching of hoisted layers
 #define GR_CACHE_HOISTED_LAYERS 0
 
 // GrPictureInfo stores the atlas plots used by a single picture. A single
 // plot may be used to store layers from multiple pictures.
 struct GrPictureInfo {
@@ skipping 119 matching lines @@
     // GrCachedLayer proper
     GrCachedLayer(uint32_t pictureID, unsigned start, unsigned stop,
                   const SkIRect& bounds, const SkMatrix& ctm,
                   const unsigned* key, int keySize,
                   const SkPaint* paint)
         : fKey(pictureID, ctm, key, keySize, true)
         , fStart(start)
         , fStop(stop)
         , fBounds(bounds)
         , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL)
+        , fFilter(NULL)
         , fTexture(NULL)
         , fRect(SkIRect::MakeEmpty())
         , fPlot(NULL)
         , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID);
+
+        if (fPaint) {
+            fFilter = SkSafeRef(fPaint->getImageFilter());
+            fPaint->setImageFilter(NULL);
+        }
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
+        SkSafeUnref(fFilter);
         SkDELETE(fPaint);
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
     // TODO: remove these when GrCachedLayer & ReplacementInfo fuse
     const unsigned* key() const { return fKey.key(); }
     int keySize() const { return fKey.keySize(); }
 
     unsigned start() const { return fStart; }
     // TODO: make bound debug only
     const SkIRect& bound() const { return fBounds; }
     unsigned stop() const { return fStop; }
     void setTexture(GrTexture* texture, const SkIRect& rect) {
         SkRefCnt_SafeAssign(fTexture, texture);
         fRect = rect;
     }
     GrTexture* texture() { return fTexture; }
     const SkPaint* paint() const { return fPaint; }
+    const SkImageFilter* filter() const { return fFilter; }
     const SkIRect& rect() const { return fRect; }
 
     void setPlot(GrPlot* plot) {
         SkASSERT(NULL == plot || NULL == fPlot);
         fPlot = plot;
     }
     GrPlot* plot() { return fPlot; }
 
     bool isAtlased() const { return SkToBool(fPlot); }
 
     void setLocked(bool locked) { fLocked = locked; }
     bool locked() const { return fLocked; }
 
     SkDEBUGCODE(const GrPlot* plot() const { return fPlot; })
     SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;)
 
 private:
     const Key       fKey;
 
     // The "saveLayer" operation index of the cached layer
     const unsigned  fStart;
     // The final "restore" operation index of the cached layer
     const unsigned  fStop;
 
     const SkIRect   fBounds;
 
     // The paint used when dropping the layer down into the owning canvas.
     // Can be NULL. This class makes a copy for itself.
-    const SkPaint*  fPaint;
+    SkPaint*  fPaint;
+
+    // The imagefilter that needs to be applied to the layer prior to it being
+    // composited with the rest of the scene.
+    const SkImageFilter* fFilter;
 
     // fTexture is a ref on the atlasing texture for atlased layers and a
     // ref on a GrTexture for non-atlased textures.
     GrTexture*      fTexture;
 
     // For both atlased and non-atlased layers 'fRect' contains the  bound of
     // the layer in whichever texture it resides. It is empty when 'fTexture'
     // is NULL.
     SkIRect         fRect;
 
@@ skipping 144 matching lines @@
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif