Make filters use SkImage instead of SkBitmap

src/effects/SkPictureImageFilter.cpp

 /*
  * Copyright 2013 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 "SkPictureImageFilter.h"
-#include "SkDevice.h"
+#include "SkSurface.h"
 #include "SkCanvas.h"
 #include "SkReadBuffer.h"
 #include "SkSurfaceProps.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 SkPictureImageFilter::SkPictureImageFilter(const SkPicture* picture, uint32_t uniqueID)
     : INHERITED(0, 0, NULL, uniqueID)
     , fPicture(SkSafeRef(picture))
     , fCropRect(picture ? picture->cullRect() : SkRect::MakeEmpty())
@@ skipping 63 matching lines @@
             fPicture->flatten(buffer);
         }
     }
     buffer.writeRect(fCropRect);
     buffer.writeInt(fPictureResolution);
     if (kLocalSpace_PictureResolution == fPictureResolution) {
         buffer.writeInt(fFilterLevel);
     }
 }
 
-bool SkPictureImageFilter::onFilterImage(Proxy* proxy, const SkBitmap&, const Context& ctx,
-                                         SkBitmap* result, SkIPoint* offset) const {
+bool SkPictureImageFilter::onFilterImage(Proxy* proxy, SkImage&, const Context& ctx,
+                                         SkAutoTUnref<SkImage>& result, SkIPoint* offset) const {
     if (!fPicture) {
         offset->fX = offset->fY = 0;
         return true;
     }
 
     SkRect floatBounds;
     ctx.ctm().mapRect(&floatBounds, fCropRect);
     SkIRect bounds = floatBounds.roundOut();
     if (!bounds.intersect(ctx.clipBounds())) {
         return false;
     }
 
     if (bounds.isEmpty()) {
         offset->fX = offset->fY = 0;
         return true;
     }
 
-    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.get()) {
         return false;
     }
 
     if (kDeviceSpace_PictureResolution == fPictureResolution || 
         0 == (ctx.ctm().getType() & ~SkMatrix::kTranslate_Mask)) {
-        drawPictureAtDeviceResolution(proxy, device.get(), bounds, ctx);        
+        drawPictureAtSurfaceResolution(proxy, surface.get(), bounds, ctx);        
     } else {
-        drawPictureAtLocalResolution(proxy, device.get(), bounds, ctx);
+        drawPictureAtLocalResolution(proxy, surface.get(), bounds, ctx);
     }
 
-    *result = device.get()->accessBitmap(false);
+    SkImage* snapshot = surface->newImageSnapshot(SkSurface::kYes_Budgeted);
+    if (NULL == snapshot) {
+        return false;
+    }
+    result.reset(snapshot);
+
     offset->fX = bounds.fLeft;
     offset->fY = bounds.fTop;
     return true;
 }
 
-void SkPictureImageFilter::drawPictureAtDeviceResolution(Proxy* proxy, SkBaseDevice* device,
-                                                         const SkIRect& deviceBounds,
+void SkPictureImageFilter::drawPictureAtSurfaceResolution(Proxy* proxy, SkSurface* surface,
+                                                         const SkIRect& surfaceBounds,
                                                          const Context& ctx) const {
     // Pass explicit surface props, as the simplified canvas constructor discards device properties.
     // FIXME: switch back to the public constructor (and unfriend) after
     //        https://code.google.com/p/skia/issues/detail?id=3142 is fixed.
-    SkCanvas canvas(device, proxy->surfaceProps(), SkCanvas::kDefault_InitFlags);
+    SkCanvas* canvas = surface->getCanvas(); //TODO:(surface, proxy->surfaceProps(), SkCanvas::kDefault_InitFlags);
 
-    canvas.translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
-    canvas.concat(ctx.ctm());
-    canvas.drawPicture(fPicture);
+    canvas->translate(-SkIntToScalar(surfaceBounds.fLeft), -SkIntToScalar(surfaceBounds.fTop));
+    canvas->concat(ctx.ctm());
+    canvas->drawPicture(fPicture);
 }
 
-void SkPictureImageFilter::drawPictureAtLocalResolution(Proxy* proxy, SkBaseDevice* device,
-                                                        const SkIRect& deviceBounds,
+void SkPictureImageFilter::drawPictureAtLocalResolution(Proxy* proxy, SkSurface* surface,
+                                                        const SkIRect& surfaceBounds,
                                                         const Context& ctx) const {
     SkMatrix inverseCtm;
     if (!ctx.ctm().invert(&inverseCtm))
         return;
     SkRect localBounds = SkRect::Make(ctx.clipBounds());
     inverseCtm.mapRect(&localBounds);
     if (!localBounds.intersect(fCropRect))
         return;
     SkIRect localIBounds = localBounds.roundOut();
-    SkAutoTUnref<SkBaseDevice> localDevice(proxy->createDevice(localIBounds.width(), localIBounds.height()));
+    SkAutoTUnref<SkSurface> localSurface(proxy->createSurface(localIBounds.width(), localIBounds.height()));
+
 
     // Pass explicit surface props, as the simplified canvas constructor discards device properties.
     // FIXME: switch back to the public constructor (and unfriend) after
     //        https://code.google.com/p/skia/issues/detail?id=3142 is fixed.
-    SkCanvas localCanvas(localDevice, proxy->surfaceProps(), SkCanvas::kDefault_InitFlags);
-    localCanvas.translate(-SkIntToScalar(localIBounds.fLeft), -SkIntToScalar(localIBounds.fTop));
-    localCanvas.drawPicture(fPicture);
+    SkCanvas* localCanvas = localSurface->getCanvas(); // TODO :PROPS!
+    localCanvas->translate(-SkIntToScalar(localIBounds.fLeft), -SkIntToScalar(localIBounds.fTop));
+    localCanvas->drawPicture(fPicture);
+
+    SkAutoTUnref<SkImage> image(localSurface->newImageSnapshot(SkSurface::kYes_Budgeted));
+    if (NULL == image) {
+        return;
+    }
 
     // Pass explicit surface props, as the simplified canvas constructor discards device properties.
     // FIXME: switch back to the public constructor (and unfriend) after
     //        https://code.google.com/p/skia/issues/detail?id=3142 is fixed.
-    SkCanvas canvas(device, proxy->surfaceProps(), SkCanvas::kDefault_InitFlags);
-
-    canvas.translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
-    canvas.concat(ctx.ctm());
+    SkCanvas* canvas = surface->getCanvas(); // TODO: (device, proxy->surfaceProps(), SkCanvas::kDefault_InitFlags);
+    canvas->translate(-SkIntToScalar(surfaceBounds.fLeft), -SkIntToScalar(surfaceBounds.fTop));
+    canvas->concat(ctx.ctm());
     SkPaint paint;
     paint.setFilterLevel(fFilterLevel);
-    canvas.drawBitmap(localDevice.get()->accessBitmap(false), SkIntToScalar(localIBounds.fLeft),
+    canvas->drawImage(image, SkIntToScalar(localIBounds.fLeft),
                       SkIntToScalar(localIBounds.fTop), &paint);
     //canvas.drawPicture(fPicture);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkPictureImageFilter::toString(SkString* str) const {
     str->appendf("SkPictureImageFilter: (");
     str->appendf("crop: (%f,%f,%f,%f) ", 
                  fCropRect.fLeft, fCropRect.fTop, fCropRect.fRight, fCropRect.fBottom);
     if (fPicture) {
         str->appendf("picture: (%f,%f,%f,%f)",
                      fPicture->cullRect().fLeft, fPicture->cullRect().fTop,
                      fPicture->cullRect().fRight, fPicture->cullRect().fBottom);
     }
     str->append(")");
 }
 #endif