Make filters use SkImage instead of SkBitmap

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 1093 matching lines @@
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
     while (iter.next()) {
         SkBaseDevice* dstDev = iter.fDevice;
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !dstDev->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(dstDev, fProps);
-            SkBitmap dst;
+            SkAutoTUnref<const SkImage> dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             SkAutoTUnref<SkImage> src(srcDev->newImageSnapshot());
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
-            SkIRect clipBounds = SkIRect::MakeWH(srcDev->width(), srcDev->height());
+            SkIRect clipBounds = SkIRect::MakeWH(src->width(), src->height());
             SkAutoTUnref<SkImageFilter::Cache> cache(dstDev->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
-            SkBitmap srcBitmap;  // TODO: remove once filters accept SkImage
-#if SK_SUPPORT_GPU
-            // TODO: Gpu devices need bitmap that came from gpu, not through
-            // getROPixels. Remove once filters accept SkImage.
-            if (NULL != src->getTexture()) {
-                SkImageFilter::WrapTexture(src->getTexture(), src->width(), src->height(),
-                                           &srcBitmap);
-            } else
-#endif
-            {
-                as_IB(src)->getROPixels(&srcBitmap);
-            }
-            if (!srcBitmap.empty()) {
-                if (filter->filterImage(&proxy, srcBitmap, ctx, &dst, &offset)) {
-                    SkPaint tmpUnfiltered(*paint);
-                    tmpUnfiltered.setImageFilter(NULL);
-                    dstDev->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                       tmpUnfiltered);
-                }
+            if (filter->filterImage(&proxy, src, ctx, dst, &offset)) {
+                SkPaint tmpUnfiltered(*paint);
+                tmpUnfiltered.setImageFilter(NULL);
+                dstDev->drawImageAsSprite(iter, *dst, pos.x() + offset.x(), pos.y() + offset.y(),
+                                          tmpUnfiltered);
             }
         } else {
             dstDev->drawDevice(iter, srcDev, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 void SkCanvas::onDrawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint* paint) {
     if (gTreatSpriteAsBitmap) {
@@ skipping 16 matching lines @@
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
 
     while (iter.next()) {
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(iter.fDevice, fProps);
-            SkBitmap dst;
+            SkAutoTUnref<SkImage> src(SkNewImageFromBitmap(bitmap, NULL));
+            SkAutoTUnref<const SkImage> dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
             const SkIRect clipBounds = bitmap.bounds();
             SkAutoTUnref<SkImageFilter::Cache> cache(iter.fDevice->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
-            if (filter->filterImage(&proxy, bitmap, ctx, &dst, &offset)) {
+            if (filter->filterImage(&proxy, src, ctx, dst, &offset)) {
                 SkPaint tmpUnfiltered(*paint);
                 tmpUnfiltered.setImageFilter(NULL);
-                iter.fDevice->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                         tmpUnfiltered);
+                iter.fDevice->drawImageAsSprite(iter, *dst, pos.x() + offset.x(),
+                                                pos.y() + offset.y(), tmpUnfiltered);
             }
         } else {
             iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 void SkCanvas::onDrawImageAsSprite(const SkImage& image, int x, int y, const SkPaint* paint) {
     if (gTreatSpriteAsBitmap) {
         this->save();
         this->resetMatrix();
         this->drawImage(&image, SkIntToScalar(x), SkIntToScalar(y), paint);
         this->restore();
         return;
     }
 
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImageAsSprite()");
 
-    SkBitmap src;
-    if (!as_IB(&image)->getROPixels(&src)) {
-        return;
-    }
-
     SkPaint tmp;
     if (NULL == paint) {
         paint = &tmp;
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kImage_Type)
 
     while (iter.next()) {
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !iter.fDevice->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(iter.fDevice, fProps);
-            SkBitmap dst;
+            SkAutoTUnref<const SkImage> dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
             const SkIRect clipBounds = SkIRect::MakeWH(image.width(), image.height());
             SkAutoTUnref<SkImageFilter::Cache> cache(iter.fDevice->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
-            if (filter->filterImage(&proxy, src, ctx, &dst, &offset)) {
+            if (filter->filterImage(&proxy, &image, ctx, dst, &offset)) {
                 SkPaint tmpUnfiltered(*paint);
                 tmpUnfiltered.setImageFilter(NULL);
-                SkAutoTUnref<SkImage> dstImage(SkNewImageFromBitmap(dst, NULL));
-                iter.fDevice->drawImageAsSprite(iter, *dstImage, pos.x() + offset.x(),
+                iter.fDevice->drawImageAsSprite(iter, *dst, pos.x() + offset.x(),
                                                 pos.y() + offset.y(), tmpUnfiltered);
             }
         } else {
             iter.fDevice->drawImageAsSprite(iter, image, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ skipping 1376 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }