Update TileImageFilter to sk_sp

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 "SkCanvas.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"
 
-SkImageFilter* SkTileImageFilter::Create(const SkRect& srcRect, const SkRect& dstRect,
-                                         SkImageFilter* input) {
+sk_sp<SkImageFilter> SkTileImageFilter::Make(const SkRect& srcRect, const SkRect& dstRect,
+                                             sk_sp<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);
+            return input;
         }
         CropRect cropRect(ir);
         return SkOffsetImageFilter::Make(dstRect.x() - srcRect.x(),
                                          dstRect.y() - srcRect.y(),
-                                         sk_ref_sp<SkImageFilter>(input),
-                                         &cropRect).release();
+                                         std::move(input),
+                                         &cropRect);
     }
-    return new SkTileImageFilter(srcRect, dstRect, input);
+    return sk_sp<SkImageFilter>(new SkTileImageFilter(srcRect, dstRect, std::move(input)));
 }
 
 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;
     }
@@ skipping 86 matching lines @@
 
 SkRect SkTileImageFilter::computeFastBounds(const SkRect& src) const {
     return fDstRect;
 }
 
 sk_sp<SkFlattenable> SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkRect src, dst;
     buffer.readRect(&src);
     buffer.readRect(&dst);
-    return sk_sp<SkFlattenable>(Create(src, dst, common.getInput(0).get()));
+    return Make(src, dst, common.getInput(0));
 }
 
 void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeRect(fSrcRect);
     buffer.writeRect(fDstRect);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkTileImageFilter::toString(SkString* str) const {
     str->appendf("SkTileImageFilter: (");
     str->appendf("src: %.2f %.2f %.2f %.2f",
                  fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBottom);
     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