Switch SkPictureImageFilter over to new onFilterImage interface

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 "SkCanvas.h"
 #include "SkReadBuffer.h"
-#include "SkSurfaceProps.h"
+#include "SkSpecialImage.h"
+#include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 SkPictureImageFilter::SkPictureImageFilter(const SkPicture* picture)
     : INHERITED(0, 0, nullptr)
     , fPicture(SkSafeRef(picture))
     , fCropRect(picture ? picture->cullRect() : SkRect::MakeEmpty())
     , fPictureResolution(kDeviceSpace_PictureResolution) 
     , fFilterQuality(kLow_SkFilterQuality) {
 }
@@ skipping 54 matching lines @@
             fPicture->flatten(buffer);
         }
     }
     buffer.writeRect(fCropRect);
     buffer.writeInt(fPictureResolution);
     if (kLocalSpace_PictureResolution == fPictureResolution) {
         buffer.writeInt(fFilterQuality);
     }
 }
 
-bool SkPictureImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap&,
-                                                   const Context& ctx,
-                                                   SkBitmap* result, SkIPoint* offset) const {
+SkSpecialImage* SkPictureImageFilter::onFilterImage(SkSpecialImage* source, const Context& ctx,
+                                                    SkIPoint* offset) const {
     if (!fPicture) {
         offset->fX = offset->fY = 0;
-        return true;
+        return nullptr;
     }
 
     SkRect floatBounds;
     ctx.ctm().mapRect(&floatBounds, fCropRect);
     SkIRect bounds = floatBounds.roundOut();
     if (!bounds.intersect(ctx.clipBounds())) {
-        return false;
+        return nullptr;
     }
 
     if (bounds.isEmpty()) {
         offset->fX = offset->fY = 0;
-        return true;
+        return nullptr;

[Stephen White, 2016/03/22 19:58:49]

I think this will change the behaviour from continuing processing with a
transparent black image to aborting filter processing.

e.g.,

SkPictureImageFilter -> SkColorFilterImageFilter

where the color filter affects transparent black.

I think we need some way to signal the DAG to continue, probably some kind of
"canonical transparent image" to return.

(OTOH, it looks like the above bounds intersection should probably also be
returning that canonical transparent image).

[robertphillips, 2016/03/25 16:53:18]

I have updated the two above calls sites to duplicate the prior behavior (i.e.,
returning the unmodified source).

     }
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
-    if (nullptr == device.get()) {
-        return false;
+    SkImageInfo info = SkImageInfo::MakeN32(bounds.width(), bounds.height(), kPremul_SkAlphaType);
+    sk_sp<SkSpecialSurface> surf(source->makeSurface(info));
+    if (!surf) {
+        return nullptr;
     }
 
+    SkCanvas* canvas = surf->getCanvas();
+    SkASSERT(canvas);
+
+    canvas->clear(0x0);
+
     if (kDeviceSpace_PictureResolution == fPictureResolution || 
         0 == (ctx.ctm().getType() & ~SkMatrix::kTranslate_Mask)) {
-        this->drawPictureAtDeviceResolution(device.get(), bounds, ctx);        
+        this->drawPictureAtDeviceResolution(canvas, bounds, ctx);        
     } else {
-        this->drawPictureAtLocalResolution(proxy, device.get(), bounds, ctx);
+        this->drawPictureAtLocalResolution(source, canvas, bounds, ctx);
     }
 
-    *result = device.get()->accessBitmap(false);
     offset->fX = bounds.fLeft;
     offset->fY = bounds.fTop;
-    return true;
+    return surf->makeImageSnapshot().release();
 }
 
-void SkPictureImageFilter::drawPictureAtDeviceResolution(SkBaseDevice* device,
+void SkPictureImageFilter::drawPictureAtDeviceResolution(SkCanvas* canvas,
                                                          const SkIRect& deviceBounds,
                                                          const Context& ctx) const {
-    SkCanvas canvas(device);
-
-    canvas.translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
-    canvas.concat(ctx.ctm());
-    canvas.drawPicture(fPicture);
+    canvas->translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
+    canvas->concat(ctx.ctm());
+    canvas->drawPicture(fPicture);
 }
 
-void SkPictureImageFilter::drawPictureAtLocalResolution(Proxy* proxy, SkBaseDevice* device,
+void SkPictureImageFilter::drawPictureAtLocalResolution(SkSpecialImage* source,
+                                                        SkCanvas* canvas,
                                                         const SkIRect& deviceBounds,
                                                         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()));
 
-    SkCanvas localCanvas(localDevice);
-    localCanvas.translate(-SkIntToScalar(localIBounds.fLeft), -SkIntToScalar(localIBounds.fTop));
-    localCanvas.drawPicture(fPicture);
+    sk_sp<SkSpecialImage> localImg;
+    {                                                            
+        const SkImageInfo info = SkImageInfo::MakeN32(localIBounds.width(), localIBounds.height(),
+                                                      kPremul_SkAlphaType);
 
-    SkCanvas canvas(device);
+        sk_sp<SkSpecialSurface> localSurface(source->makeSurface(info));
+        if (!localSurface) {
+            return;
+        }
 
-    canvas.translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
-    canvas.concat(ctx.ctm());
-    SkPaint paint;
-    paint.setFilterQuality(fFilterQuality);
-    canvas.drawBitmap(localDevice.get()->accessBitmap(false), SkIntToScalar(localIBounds.fLeft),
-                      SkIntToScalar(localIBounds.fTop), &paint);
+        SkCanvas* localCanvas = localSurface->getCanvas();
+        SkASSERT(localCanvas);
+
+        localCanvas->translate(-SkIntToScalar(localIBounds.fLeft),
+                               -SkIntToScalar(localIBounds.fTop));
+        localCanvas->drawPicture(fPicture);
+
+        localImg = localSurface->makeImageSnapshot();
+        SkASSERT(localImg);
+    }
+
+    {
+        canvas->translate(-SkIntToScalar(deviceBounds.fLeft), -SkIntToScalar(deviceBounds.fTop));
+        canvas->concat(ctx.ctm());
+        SkPaint paint;
+        paint.setFilterQuality(fFilterQuality);
+
+        localImg->draw(canvas,
+                       SkIntToScalar(localIBounds.fLeft),
+                       SkIntToScalar(localIBounds.fTop),
+                       &paint);
+    }
 }
 
 #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