Update SkAlphaThresholdFilter to sk_sp

src/effects/SkAlphaThresholdFilter.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 "SkAlphaThresholdFilter.h"
+
 #include "SkBitmap.h"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRegion.h"
 #if SK_SUPPORT_GPU
 #include "GrDrawContext.h"
 #endif
 
 class SK_API SkAlphaThresholdFilterImpl : public SkImageFilter {
 public:
     SkAlphaThresholdFilterImpl(const SkRegion& region, SkScalar innerThreshold,
-                               SkScalar outerThreshold, SkImageFilter* input);
+                               SkScalar outerThreshold, sk_sp<SkImageFilter> input);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
     friend void SkAlphaThresholdFilter::InitializeFlattenables();
 
 protected:
     void flatten(SkWriteBuffer&) const override;
 
     bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                  SkBitmap* result, SkIPoint* offset) const override;
@@ skipping 10 matching lines @@
 };
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkAlphaThresholdFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkAlphaThresholdFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 static SkScalar pin_0_1(SkScalar x) {
     return SkMinScalar(SkMaxScalar(x, 0), 1);
 }
 
-SkImageFilter* SkAlphaThresholdFilter::Create(const SkRegion& region,
-                                              SkScalar innerThreshold,
-                                              SkScalar outerThreshold,
-                                              SkImageFilter* input) {
+sk_sp<SkImageFilter> SkAlphaThresholdFilter::Make(const SkRegion& region,
+                                                  SkScalar innerThreshold,
+                                                  SkScalar outerThreshold,
+                                                  sk_sp<SkImageFilter> input) {
     innerThreshold = pin_0_1(innerThreshold);
     outerThreshold = pin_0_1(outerThreshold);
     if (!SkScalarIsFinite(innerThreshold) || !SkScalarIsFinite(outerThreshold)) {
         return nullptr;
     }
-    return new SkAlphaThresholdFilterImpl(region, innerThreshold, outerThreshold, input);
+    return sk_sp<SkImageFilter>(new SkAlphaThresholdFilterImpl(region, innerThreshold,
+                                                               outerThreshold, std::move(input)));
 }
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrTextureAccess.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 
@@ skipping 190 matching lines @@
 }
 
 #endif
 
 SkFlattenable* SkAlphaThresholdFilterImpl::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar inner = buffer.readScalar();
     SkScalar outer = buffer.readScalar();
     SkRegion rgn;
     buffer.readRegion(&rgn);
-    return SkAlphaThresholdFilter::Create(rgn, inner, outer, common.getInput(0).get());
+    return SkAlphaThresholdFilter::Make(rgn, inner, outer, common.getInput(0)).release();
 }
 
 SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(const SkRegion& region,
                                                        SkScalar innerThreshold,
                                                        SkScalar outerThreshold,
-                                                       SkImageFilter* input)
-    : INHERITED(1, &input)
+                                                       sk_sp<SkImageFilter> input)
+    : INHERITED(&input, 1, nullptr)
     , fRegion(region)
     , fInnerThreshold(innerThreshold)
     , fOuterThreshold(outerThreshold) {
 }
 
 #if SK_SUPPORT_GPU
 bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
                                                      GrTexture* texture,
                                                      const SkMatrix& inMatrix,
                                                      const SkIRect& bounds) const {
@@ skipping 113 matching lines @@
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkAlphaThresholdFilterImpl::toString(SkString* str) const {
     str->appendf("SkAlphaThresholdImageFilter: (");
     str->appendf("inner: %f outer: %f", fInnerThreshold, fOuterThreshold);
     str->append(")");
 }
 #endif