Make filters use SkImage instead of SkBitmap

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 "GrLayerHoister.h"
 #include "GrLayerCache.h"
-#include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
-
 #include "SkCanvas.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDeviceProperties.h"
 #include "SkGpuDevice.h"
 #include "SkGrPixelRef.h"
+#include "SkImagePriv.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,
@@ skipping 242 matching lines @@
                                 pict->drawablePicts(), pict->drawableCount(),
                                 layer->start() + 1, layer->stop(), initialCTM);
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 }
 
-SkBitmap wrap_texture(GrTexture* texture) {
+static SkImage* wrap_texture(GrTexture* texture) {
     SkASSERT(texture);
-
     SkBitmap result;
     result.setInfo(texture->surfacePriv().info());
     result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (result.info(), texture)))->unref();
-    return result;
+    return SkNewImageFromBitmapTexture(result, texture->desc().fSampleCnt,
+                                       SkSurface::kYes_Budgeted);
 }
 
 void GrLayerHoister::FilterLayer(GrContext* context,
                                  SkGpuDevice* device,
                                  const GrHoistedLayer& info) {
     GrCachedLayer* layer = info.fLayer;
 
     SkASSERT(layer->filter());
 
     static const int kDefaultCacheSize = 32 * 1024 * 1024;
 
-    SkBitmap filteredBitmap;
     SkIPoint offset = SkIPoint::Make(0, 0);
 
     const SkIPoint filterOffset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
 
     SkMatrix totMat = SkMatrix::I();
     totMat.preConcat(info.fPreMat);
     totMat.preConcat(info.fLocalMat);
     totMat.postTranslate(-SkIntToScalar(filterOffset.fX), -SkIntToScalar(filterOffset.fY));
 
     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(totMat, clipBounds, cache);
 
     SkDeviceImageFilterProxy proxy(device, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
-    const SkBitmap src = wrap_texture(layer->texture());
-
-    if (!layer->filter()->filterImage(&proxy, src, filterContext, &filteredBitmap, &offset)) {
+    SkAutoTUnref<const SkImage> src(wrap_texture(layer->texture()));
+    SkAutoTUnref<const SkImage> filteredImage;
+    if (!layer->filter()->filterImage(&proxy, src, filterContext, filteredImage, &offset)) {
         // Filtering failed. Press on with the unfiltered version.
         return;
     }
 
-    SkIRect newRect = SkIRect::MakeWH(filteredBitmap.width(), filteredBitmap.height());
-    layer->setTexture(filteredBitmap.getTexture(), newRect);
+    SkIRect newRect = SkIRect::MakeWH(filteredImage->width(), filteredImage->height());
+    layer->setTexture(filteredImage->getTexture(), newRect);
     layer->setOffset(offset);
 }
 
 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->srcIR().fLeft, layer->srcIR().fTop);
 
         // Each non-atlased layer has its own GrTexture
@@ skipping 46 matching lines @@
 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
 }