Switch new SkImageFilter internal methods over to sk_sp

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 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 "SkImageFilter.h"
 #include "SkImageFilterCacheKey.h"
 
@@ skipping 196 matching lines @@
         SkImageFilter* input = this->getInput(i);
         buffer.writeBool(input != nullptr);
         if (input != nullptr) {
             buffer.writeFlattenable(input);
         }
     }
     buffer.writeRect(fCropRect.rect());
     buffer.writeUInt(fCropRect.flags());
 }
 
-SkSpecialImage* SkImageFilter::filterImage(SkSpecialImage* src, const Context& context,
-                                           SkIPoint* offset) const {
+sk_sp<SkSpecialImage> SkImageFilter::filterImage(SkSpecialImage* src, const Context& context,
+                                                 SkIPoint* offset) const {
     SkASSERT(src && offset);
 
     uint32_t srcGenID = fUsesSrcInput ? src->uniqueID() : 0;
     const SkIRect srcSubset = fUsesSrcInput ? src->subset() : SkIRect::MakeWH(0, 0);
     Cache::Key key(fUniqueID, context.ctm(), context.clipBounds(), srcGenID, srcSubset);
     if (context.cache()) {
         SkSpecialImage* result = context.cache()->get(key, offset);
         if (result) {
-            return SkRef(result);
+            return sk_sp<SkSpecialImage>(SkRef(result));
         }
     }
 
-    SkSpecialImage* result = this->onFilterImage(src, context, offset);
+    sk_sp<SkSpecialImage> result(this->onFilterImage(src, context, offset));
     if (result && context.cache()) {
-        context.cache()->set(key, result, *offset);
+        context.cache()->set(key, result.get(), *offset);
         SkAutoMutexAcquire mutex(fMutex);
         fCacheKeys.push_back(key);
     }
 
     return result;
 }
 
 bool SkImageFilter::filterImageDeprecated(Proxy* proxy, const SkBitmap& src,
                                           const Context& context,
                                           SkBitmap* result, SkIPoint* offset) const {
@@ skipping 29 matching lines @@
     SkImageFilter* input = this->getInput(index);
     if (!input) {
         return true;
     }
 
     sk_sp<SkSpecialImage> specialSrc(SkSpecialImage::internal_fromBM(proxy, src));
     if (!specialSrc) {
         return false;
     }
 
-    SkAutoTUnref<SkSpecialImage> tmp(input->onFilterImage(specialSrc.get(),
-                                                          this->mapContext(ctx),
-                                                          offset));
+    sk_sp<SkSpecialImage> tmp(input->onFilterImage(specialSrc.get(),
+                                                   this->mapContext(ctx),
+                                                   offset));
     if (!tmp) {
         return false;
     }
 
     return tmp->internal_getBM(result);
 }
 
 SkIRect SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm,
                                  MapDirection direction) const {
     if (kReverse_MapDirection == direction) {
@@ skipping 38 matching lines @@
                                             SkBitmap*, SkIPoint*) const {
     // Only classes that now use the new SkSpecialImage-based path will not have
     // onFilterImageDeprecated methods. For those classes we should never be
     // calling this method.
     SkASSERT(0);
     return false;
 }
 
 // SkImageFilter-derived classes that do not yet have their own onFilterImage
 // implementation convert back to calling the deprecated filterImage method
-SkSpecialImage* SkImageFilter::onFilterImage(SkSpecialImage* src, const Context& ctx,
-                                             SkIPoint* offset) const {
+sk_sp<SkSpecialImage> SkImageFilter::onFilterImage(SkSpecialImage* src, const Context& ctx,
+                                                   SkIPoint* offset) const {
     SkBitmap srcBM, resultBM;
 
     if (!src->internal_getBM(&srcBM)) {
         return nullptr;
     }
 
     // This is the only valid call to the old filterImage path
     if (!this->filterImageDeprecated(src->internal_getProxy(), srcBM, ctx, &resultBM, offset)) {
         return nullptr;
     }
 
-    return SkSpecialImage::internal_fromBM(src->internal_getProxy(), resultBM).release();
+    return SkSpecialImage::internal_fromBM(src->internal_getProxy(), resultBM);
 }
 
 bool SkImageFilter::canFilterImageGPU() const {
     return this->asFragmentProcessor(nullptr, nullptr, SkMatrix::I(), SkIRect());
 }
 
 bool SkImageFilter::filterImageGPUDeprecated(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                              SkBitmap* result, SkIPoint* offset) const {
 #if SK_SUPPORT_GPU
     SkBitmap input = src;
@@ skipping 114 matching lines @@
     SkCanvas* canvas = surf->getCanvas();
     SkASSERT(canvas);
 
     canvas->clear(0x0);
 
     src->draw(canvas, offX, offY, nullptr);
 
     return surf->makeImageSnapshot();
 }
 
-SkSpecialImage* SkImageFilter::applyCropRect(const Context& ctx,
-                                             SkSpecialImage* src,
-                                             SkIPoint* srcOffset,
-                                             SkIRect* bounds) const {
+sk_sp<SkSpecialImage> SkImageFilter::applyCropRect(const Context& ctx,
+                                                   SkSpecialImage* src,
+                                                   SkIPoint* srcOffset,
+                                                   SkIRect* bounds) const {
     SkIRect srcBounds;
     srcBounds = SkIRect::MakeXYWH(srcOffset->fX, srcOffset->fY, src->width(), src->height());
 
     SkIRect dstBounds = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
     fCropRect.applyTo(dstBounds, ctx.ctm(), bounds);
     if (!bounds->intersect(ctx.clipBounds())) {
         return nullptr;
     }
 
     if (srcBounds.contains(*bounds)) {
-        return SkRef(src);
+        return sk_sp<SkSpecialImage>(SkRef(src));
     } else {
         sk_sp<SkSpecialImage> img(pad_image(src,
                                             bounds->width(), bounds->height(),
                                             srcOffset->x() - bounds->x(),
                                             srcOffset->y() - bounds->y()));
         *srcOffset = SkIPoint::Make(bounds->x(), bounds->y());
-        return img.release();
+        return img;
     }
 }
 
 SkIRect SkImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                       MapDirection direction) const {
     if (fInputCount < 1) {
         return src;
     }
 
     SkIRect totalBounds;
@@ skipping 32 matching lines @@
     return SkMatrixImageFilter::Create(matrix, filterQuality, input);
 }
 
 SkImageFilter* SkImageFilter::newWithLocalMatrix(const SkMatrix& matrix) const {
     // SkLocalMatrixImageFilter takes SkImage* in its factory, but logically that parameter
     // is *always* treated as a const ptr. Hence the const-cast here.
     //
     return SkLocalMatrixImageFilter::Create(matrix, const_cast<SkImageFilter*>(this));
 }
 
-SkSpecialImage* SkImageFilter::filterInput(int index,
-                                           SkSpecialImage* src,
-                                           const Context& ctx,
-                                           SkIPoint* offset) const {
+sk_sp<SkSpecialImage> SkImageFilter::filterInput(int index,
+                                                 SkSpecialImage* src,
+                                                 const Context& ctx,
+                                                 SkIPoint* offset) const {
     SkImageFilter* input = this->getInput(index);
     if (!input) {
-        return SkRef(src);
+        return sk_sp<SkSpecialImage>(SkRef(src));
     }
 
-    SkAutoTUnref<SkSpecialImage> result(input->filterImage(src, this->mapContext(ctx), offset));
+    sk_sp<SkSpecialImage> result(input->filterImage(src, this->mapContext(ctx), offset));
 
 #if SK_SUPPORT_GPU
     if (src->peekTexture() && result && !result->peekTexture()) {
         // Keep the result on the GPU - this is still required for some
         // image filters that don't support GPU in all cases
         GrContext* context = src->peekTexture()->getContext();
-        return result->makeTextureImage(src->internal_getProxy(), context).release();
+        return result->makeTextureImage(src->internal_getProxy(), context);
     }
 #endif
 
-    return result.release();
+    return result;
 }
 
 #if SK_SUPPORT_GPU
 
 bool SkImageFilter::filterInputGPUDeprecated(int index, SkImageFilter::Proxy* proxy,
                                              const SkBitmap& src, const Context& ctx,
                                              SkBitmap* result, SkIPoint* offset) const {
     SkImageFilter* input = this->getInput(index);
     if (!input) {
         return true;
     }
 
     sk_sp<SkSpecialImage> specialSrc(SkSpecialImage::internal_fromBM(proxy, src));
     if (!specialSrc) {
         return false;
     }
 
-    SkAutoTUnref<SkSpecialImage> tmp(input->onFilterImage(specialSrc.get(),
-                                                          this->mapContext(ctx),
-                                                          offset));
+    sk_sp<SkSpecialImage> tmp(input->onFilterImage(specialSrc.get(),
+                                                   this->mapContext(ctx),
+                                                   offset));
     if (!tmp) {
         return false;
     }
 
     if (!tmp->internal_getBM(result)) {
         return false;
     }
 
     if (!result->getTexture()) {
         GrContext* context = src.getTexture()->getContext();
@@ skipping 181 matching lines @@
     }
     return dev;
 }
 
 bool SkImageFilter::DeviceProxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                                        const SkImageFilter::Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) {
     return fDevice->filterImage(filter, src, ctx, result, offset);
 }