Apply the layer's image filter to the hoisted image

src/gpu/GrLayerHoister.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 "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 
 #include "SkCanvas.h"
+#include "SkGpuDevice.h"
 #include "SkGrPixelRef.h"
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
+#include "SkSurface_Gpu.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const SkMatrix& initialMat,
                                  const SkLayerInfo::BlockInfo& info,
                                  const SkIRect& layerRect,
                                  SkTDArray<GrHoistedLayer>* needRendering,
                                  SkTDArray<GrHoistedLayer>* recycled,
@@ skipping 166 matching lines @@
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
         for (int i = 0; i < atlased.count(); ++i) {
             const GrCachedLayer* layer = atlased[i].fLayer;
             const SkPicture* pict = atlased[i].fPicture;
             const SkIPoint offset = SkIPoint::Make(layer->bound().fLeft, layer->bound().fTop);
             SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();)
 
             SkASSERT(!layerPaint || !layerPaint->getImageFilter());
+            SkASSERT(!layer->filter());
 
             atlasCanvas->save();
 
             // Add a rect clip to make sure the rendering doesn't
             // extend beyond the boundaries of the atlased sub-rect
             const SkRect bound = SkRect::Make(layer->rect());
             atlasCanvas->clipRect(bound);
             atlasCanvas->clear(0);
 
             // '-offset' maps the layer's top/left to the origin.
@@ skipping 11 matching lines @@
                                 pict->drawablePicts(), pict->drawableCount(),
                                 layer->start() + 1, layer->stop(), initialCTM);
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 }
 
+void GrLayerHoister::FilterLayer(GrContext* context, SkGpuDevice* device, GrCachedLayer* layer) {
+    SkASSERT(layer->filter());
+
+    static const int kDefaultCacheSize = 32 * 1024 * 1024;
+
+    if (layer->filter()->canFilterImageGPU()) {
+        SkBitmap filteredBitmap;
+        SkIPoint offset = SkIPoint::Make(0, 0);
+
+        SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
+        SkIRect clipBounds = layer->rect();
+
+        // This cache is transient, and is freed (along with all its contained
+        // textures) when it goes out of scope.
+        SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kDefaultCacheSize));
+        SkImageFilter::Context filterContext(SkMatrix::I(), clipBounds, cache);
+
+        if (!device->filterTexture(context, layer->texture(), layer->filter(),
+                                   filterContext, &filteredBitmap, &offset)) {
+            // Filtering failed. Press on with the unfiltered version
+            return;
+        }
+
+        // TODO: need to fix up offset
+        SkASSERT(0 == offset.fX && 0 == offset.fY);
+
+        SkIRect newRect = SkIRect::MakeWH(filteredBitmap.width(), filteredBitmap.height());
+        layer->setTexture(filteredBitmap.getTexture(), newRect);
+    }
+}
+
 void GrLayerHoister::DrawLayers(GrContext* context, const SkTDArray<GrHoistedLayer>& layers) {
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
         const SkPicture* pict = layers[i].fPicture;
         const SkIPoint offset = SkIPoint::Make(layer->bound().fLeft, layer->bound().fTop);
 
         // Each non-atlased layer has its own GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         layer->texture()->asRenderTarget(), NULL));
 
@@ skipping 12 matching lines @@
         initialCTM.preConcat(layers[i].fPreMat);
 
         layerCanvas->setMatrix(initialCTM);
         layerCanvas->concat(layers[i].fLocalMat);
 
         SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas,
                             pict->drawablePicts(), pict->drawableCount(),
                             layer->start()+1, layer->stop(), initialCTM);
 
         layerCanvas->flush();
+
+        if (layer->filter()) {
+            SkSurface_Gpu* gpuSurf = static_cast<SkSurface_Gpu*>(surface.get());
+
+            FilterLayer(context, gpuSurf->getDevice(), layer);
+        }
     }
 }
 
 void GrLayerHoister::UnlockLayers(GrContext* context,
                                   const SkTDArray<GrHoistedLayer>& layers) {
     GrLayerCache* layerCache = context->getLayerCache();
 
     for (int i = 0; i < layers.count(); ++i) {
         layerCache->removeUse(layers[i].fLayer);
     }
 
     SkDEBUGCODE(layerCache->validate();)
 }
 
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 }