Make filters use SkImage instead of SkBitmap

src/effects/SkXfermodeImageFilter.cpp

Index: src/effects/SkXfermodeImageFilter.cpp
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index 14dde88379aa7dd8f990a79f1c85dbdb9192cb5c..b8beff28bf07c5e6cab4bd79894ee2cde7ed4eb2 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -7,7 +7,7 @@
 
 #include "SkXfermodeImageFilter.h"
 #include "SkCanvas.h"
-#include "SkDevice.h"
+#include "SkSurface.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ -44,55 +44,66 @@ void SkXfermodeImageFilter::flatten(SkWriteBuffer& buffer) const {
 }
 
 bool SkXfermodeImageFilter::onFilterImage(Proxy* proxy,
-                                            const SkBitmap& src,
-                                            const Context& ctx,
-                                            SkBitmap* dst,
-                                            SkIPoint* offset) const {
-    SkBitmap background = src, foreground = src;
+                                          SkImage& src,
+                                          const Context& ctx,
+                                          SkAutoTUnref<SkImage>& dst,
+                                          SkIPoint* offset) const {
+    SkAutoTUnref<SkImage> background(SkRef(&src));
+    SkAutoTUnref<SkImage> foreground(SkRef(&src));
     SkImageFilter* backgroundInput = getInput(0);
     SkImageFilter* foregroundInput = getInput(1);
     SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
+    //TODO MAKE APPLY CROP RECT PTR TO HANDLE NULL.
     if (backgroundInput &&
-        !backgroundInput->filterImage(proxy, src, ctx, &background, &backgroundOffset)) {
-        background.reset();
+        !backgroundInput->filterImage(proxy, src, ctx, background, &backgroundOffset)) {
+        background.reset(NULL);
     }
     SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
     if (foregroundInput &&
-        !foregroundInput->filterImage(proxy, src, ctx, &foreground, &foregroundOffset)) {
-        foreground.reset();
+        !foregroundInput->filterImage(proxy, src, ctx, foreground, &foregroundOffset)) {
+        foreground.reset(NULL);
     }
 
     SkIRect bounds, foregroundBounds;
-    if (!applyCropRect(ctx, foreground, foregroundOffset, &foregroundBounds)) {
+    if (!applyCropRect(ctx, *foreground, foregroundOffset, &foregroundBounds)) {
         foregroundBounds.setEmpty();
-        foreground.reset();
+        foreground.reset(NULL);
     }
-    if (!applyCropRect(ctx, background, backgroundOffset, &bounds)) {
+    if (!applyCropRect(ctx, *background, backgroundOffset, &bounds)) {
         bounds.setEmpty();
-        background.reset();
+        background.reset(NULL);
     }
     bounds.join(foregroundBounds);
     if (bounds.isEmpty()) {
         return false;
     }
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
-    if (NULL == device.get()) {
+    SkAutoTUnref<SkSurface> surface(proxy->createSurface(bounds.width(), bounds.height()));
+    if (NULL == surface) {
         return false;
     }
-    SkCanvas canvas(device);
-    canvas.translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
+    SkCanvas* canvas = surface->getCanvas();
+    canvas->translate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
-    canvas.drawBitmap(background, SkIntToScalar(backgroundOffset.fX),
-                      SkIntToScalar(backgroundOffset.fY), &paint);
+    canvas->drawImage(background, SkIntToScalar(backgroundOffset.fX),
+                     SkIntToScalar(backgroundOffset.fY), &paint);
     paint.setXfermode(fMode);
-    canvas.drawBitmap(foreground, SkIntToScalar(foregroundOffset.fX),
+    canvas->drawImage(foreground, SkIntToScalar(foregroundOffset.fX),
                       SkIntToScalar(foregroundOffset.fY), &paint);
-    canvas.clipRect(SkRect::Make(foregroundBounds), SkRegion::kDifference_Op);
+    canvas->clipRect(SkRect::Make(foregroundBounds), SkRegion::kDifference_Op);
     paint.setColor(SK_ColorTRANSPARENT);
-    canvas.drawPaint(paint);
-    *dst = device->accessBitmap(false);
+    canvas->drawPaint(paint);
+
+    foreground.reset(NULL);
+    background.reset(NULL);
+
+    SkImage* image = surface->newImageSnapshot(SkSurface::kYes_Budgeted);
+    if (NULL == image) {
+        return false;
+    }
+    dst.reset(image);
+
     offset->fX = bounds.left();
     offset->fY = bounds.top();
     return true;
@@ -116,30 +127,30 @@ bool SkXfermodeImageFilter::canFilterImageGPU() const {
 }
 
 bool SkXfermodeImageFilter::filterImageGPU(Proxy* proxy,
-                                           const SkBitmap& src,
+                                           SkImage& src,
                                            const Context& ctx,
-                                           SkBitmap* result,
+                                           SkAutoTUnref<SkImage>& result,
                                            SkIPoint* offset) const {
-    SkBitmap background = src;
+    SkAutoTUnref<SkImage> background(SkRef(&src));
     SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
-    if (getInput(0) && !getInput(0)->getInputResultGPU(proxy, src, ctx, &background,
+    if (getInput(0) && !getInput(0)->getInputResultGPU(proxy, src, ctx, background,
                                                        &backgroundOffset)) {
         return onFilterImage(proxy, src, ctx, result, offset);
     }
-    GrTexture* backgroundTex = background.getTexture();
+    GrTexture* backgroundTex = background->getTexture();
 
     if (NULL == backgroundTex) {
         SkASSERT(false);
         return false;
     }
 
-    SkBitmap foreground = src;
+    SkAutoTUnref<SkImage> foreground(SkRef(&src));
     SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
-    if (getInput(1) && !getInput(1)->getInputResultGPU(proxy, src, ctx, &foreground,
+    if (getInput(1) && !getInput(1)->getInputResultGPU(proxy, src, ctx, foreground,
                                                        &foregroundOffset)) {
         return onFilterImage(proxy, src, ctx, result, offset);
     }
-    GrTexture* foregroundTex = foreground.getTexture();
+    GrTexture* foregroundTex = foreground->getTexture();
     GrContext* context = foregroundTex->getContext();
 
     GrFragmentProcessor* xferProcessor = NULL;
@@ -167,8 +178,7 @@ bool SkXfermodeImageFilter::filterImageGPU(Proxy* proxy,
                                   SkIntToScalar(backgroundOffset.fY-foregroundOffset.fY));
 
 
-    SkRect srcRect;
-    src.getBounds(&srcRect);
+    SkRect srcRect = SkRect::MakeWH(src.width(), src.height());
 
     GrPaint paint;
     paint.addColorTextureProcessor(foregroundTex, foregroundMatrix);
@@ -177,7 +187,9 @@ bool SkXfermodeImageFilter::filterImageGPU(Proxy* proxy,
 
     offset->fX = backgroundOffset.fX;
     offset->fY = backgroundOffset.fY;
-    WrapTexture(dst, src.width(), src.height(), result);
+    if (!WrapTexture(dst, src.width(), src.height(), result)) {
+        return false;
+    }
     return true;
 }