Switch SkTileImageFilter over to new onFilterImage interface

src/effects/SkTileImageFilter.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTileImageFilter.h"
-#include "SkBitmap.h"
+
 #include "SkCanvas.h"
-#include "SkDevice.h"
+#include "SkImage.h"
+#include "SkMatrix.h"
 #include "SkOffsetImageFilter.h"
+#include "SkPaint.h"
 #include "SkReadBuffer.h"
+#include "SkShader.h"
+#include "SkSpecialImage.h"
+#include "SkSpecialSurface.h"
+#include "SkSurface.h"
+#include "SkValidationUtils.h"
 #include "SkWriteBuffer.h"
-#include "SkMatrix.h"
-#include "SkPaint.h"
-#include "SkShader.h"
-#include "SkValidationUtils.h"
 
 SkImageFilter* SkTileImageFilter::Create(const SkRect& srcRect, const SkRect& dstRect,
                                          SkImageFilter* input) {
     if (!SkIsValidRect(srcRect) || !SkIsValidRect(dstRect)) {
         return nullptr;
     }
     if (srcRect.width() == dstRect.width() && srcRect.height() == dstRect.height()) {
         SkRect ir = dstRect;
         if (!ir.intersect(srcRect)) {
             return SkSafeRef(input);
         }
         CropRect cropRect(ir);
         return SkOffsetImageFilter::Make(dstRect.x() - srcRect.x(),
                                          dstRect.y() - srcRect.y(),
                                          sk_ref_sp<SkImageFilter>(input),
                                          &cropRect).release();
     }
     return new SkTileImageFilter(srcRect, dstRect, input);
 }
 
-bool SkTileImageFilter::onFilterImageDeprecated(Proxy* proxy, const SkBitmap& src,
-                                                const Context& ctx,
-                                                SkBitmap* dst, SkIPoint* offset) const {
-    SkBitmap source = src;
-    SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputDeprecated(0, proxy, src, ctx, &source, &srcOffset)) {
-        return false;
+sk_sp<SkSpecialImage> SkTileImageFilter::onFilterImage(SkSpecialImage* source,
+                                                       const Context& ctx,
+                                                       SkIPoint* offset) const {
+    SkIPoint inputOffset = SkIPoint::Make(0, 0);
+    sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
+    if (!input) {
+        return nullptr;
     }
 
     SkRect dstRect;
     ctx.ctm().mapRect(&dstRect, fDstRect);
     if (!dstRect.intersect(SkRect::Make(ctx.clipBounds()))) {
-        offset->fX = offset->fY = 0;
-        return true;
+        return nullptr;
     }
+
     const SkIRect dstIRect = dstRect.roundOut();
-    int w = dstIRect.width();
-    int h = dstIRect.height();
-    if (!fSrcRect.width() || !fSrcRect.height() || !w || !h) {
-        return false;
+    int dstWidth = dstIRect.width();
+    int dstHeight = dstIRect.height();
+    if (!fSrcRect.width() || !fSrcRect.height() || !dstWidth || !dstHeight) {
+        return nullptr;
     }
 
     SkRect srcRect;
     ctx.ctm().mapRect(&srcRect, fSrcRect);
     SkIRect srcIRect;
     srcRect.roundOut(&srcIRect);
-    srcIRect.offset(-srcOffset);
-    SkBitmap subset;
-    SkIRect srcBounds;
-    source.getBounds(&srcBounds);
+    srcIRect.offset(-inputOffset);
+    const SkIRect inputBounds = SkIRect::MakeWH(input->width(), input->height());
 
-    if (!SkIRect::Intersects(srcIRect, srcBounds)) {
-        offset->fX = offset->fY = 0;
-        return true;
+    if (!SkIRect::Intersects(srcIRect, inputBounds)) {
+        return nullptr;
     }
-    if (srcBounds.contains(srcIRect)) {
-        if (!source.extractSubset(&subset, srcIRect)) {
-            return false;
+
+    // We create an SkImage here b.c. it needs to be a tight fit for the tiling
+    sk_sp<SkImage> subset;
+    if (inputBounds.contains(srcIRect)) {
+        subset = input->makeTightSubset(srcIRect);
+        if (!subset) {
+            return nullptr;
         }
     } else {
-        SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(srcIRect.width(),
-                                                              srcIRect.height(),
-                                                              kPossible_TileUsage));
-        if (!device) {
-            return false;
+        const SkImageInfo info = SkImageInfo::MakeN32(srcIRect.width(), srcIRect.height(),
+                                                      kPremul_SkAlphaType);
+        sk_sp<SkSurface> surf(input->makeTightSurface(info));
+        if (!surf) {
+            return nullptr;
         }
-        SkCanvas canvas(device);
-        canvas.drawBitmap(source, SkIntToScalar(srcOffset.x()),
-                                  SkIntToScalar(srcOffset.y()));
-        subset = device->accessBitmap(false);
+
+        SkCanvas* canvas = surf->getCanvas();
+        SkASSERT(canvas);
+
+        SkPaint paint;
+        paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+
+        input->draw(canvas, 
+                    SkIntToScalar(inputOffset.x()), SkIntToScalar(inputOffset.y()),
+                    &paint);
+
+        subset = surf->makeImageSnapshot();
     }
-    SkASSERT(subset.width() == srcIRect.width());
-    SkASSERT(subset.height() == srcIRect.height());
+    SkASSERT(subset->width() == srcIRect.width());
+    SkASSERT(subset->height() == srcIRect.height());
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(w, h));
-    if (nullptr == device.get()) {
-        return false;
+    const SkImageInfo info = SkImageInfo::MakeN32(dstWidth, dstHeight, kPremul_SkAlphaType);
+
+    sk_sp<SkSpecialSurface> surf(source->makeSurface(info));
+    if (!surf) {
+        return nullptr;
     }
-    SkCanvas canvas(device);
+
+    SkCanvas* canvas = surf->getCanvas();
+    SkASSERT(canvas);
+
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
-    paint.setShader(SkShader::MakeBitmapShader(subset, SkShader::kRepeat_TileMode,
-                                               SkShader::kRepeat_TileMode));
-    canvas.translate(-dstRect.fLeft, -dstRect.fTop);
-    canvas.drawRect(dstRect, paint);
-    *dst = device->accessBitmap(false);
+    paint.setShader(subset->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode));
+    canvas->translate(-dstRect.fLeft, -dstRect.fTop);
+    canvas->drawRect(dstRect, paint);
     offset->fX = dstIRect.fLeft;
     offset->fY = dstIRect.fTop;
-    return true;
+    return surf->makeImageSnapshot();
 }
 
 SkIRect SkTileImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
                                               MapDirection direction) const {
     SkRect rect = kReverse_MapDirection == direction ? fSrcRect : fDstRect;
     ctm.mapRect(&rect);
     return rect.roundOut();
 }
 
 SkIRect SkTileImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix&, MapDirection) const {
@@ skipping 27 matching lines @@
     str->appendf(" dst: %.2f %.2f %.2f %.2f",
                  fDstRect.fLeft, fDstRect.fTop, fDstRect.fRight, fDstRect.fBottom);
     if (this->getInput(0)) {
         str->appendf("input: (");
         this->getInput(0)->toString(str);
         str->appendf(")");
     }
     str->append(")");
 }
 #endif