Update internal testing ImageFilters to sk_sp

gm/imagefiltersbase.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
 
 #include "SkBlurImageFilter.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkTestImageFilters.h"
 
 class FailImageFilter : public SkImageFilter {
 public:
     class Registrar {
     public:
         Registrar() {
             SkFlattenable::Register("FailImageFilter",
                                     FailImageFilter::CreateProc,
                                     FailImageFilter::GetFlattenableType());
         }
     };
-    static FailImageFilter* Create() { return new FailImageFilter; }
+    static sk_sp<SkImageFilter> Make() {
+        return sk_sp<SkImageFilter>(new FailImageFilter);
+    }
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(FailImageFilter)
 
 protected:
-    FailImageFilter() : INHERITED(0, nullptr) {}
+    FailImageFilter() : INHERITED(nullptr, 0, nullptr) {}
 
     bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                  SkBitmap* result, SkIPoint* offset) const override {
         return false;
     }
 
 private:
     typedef SkImageFilter INHERITED;
 };
 
 static FailImageFilter::Registrar gReg0;
 
 sk_sp<SkFlattenable> FailImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
-    return sk_sp<SkFlattenable>(FailImageFilter::Create());
+    return FailImageFilter::Make();
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void FailImageFilter::toString(SkString* str) const {
     str->appendf("FailImageFilter: (");
     str->append(")");
 }
 #endif
 
 class IdentityImageFilter : public SkImageFilter {
 public:
     class Registrar {
     public:
         Registrar() {
             SkFlattenable::Register("IdentityImageFilter",
                                     IdentityImageFilter::CreateProc,
                                     IdentityImageFilter::GetFlattenableType());
         }
     };
-    static IdentityImageFilter* Create(SkImageFilter* input = nullptr) {
-        return new IdentityImageFilter(input);
+    static sk_sp<SkImageFilter> Make(sk_sp<SkImageFilter> input) {
+        return sk_sp<SkImageFilter>(new IdentityImageFilter(std::move(input)));
     }
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(IdentityImageFilter)
+
 protected:
-    IdentityImageFilter(SkImageFilter* input) : INHERITED(1, &input) {}
-
     bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                  SkBitmap* result, SkIPoint* offset) const override {
         *result = src;
         offset->set(0, 0);
         return true;
     }
 
 private:
+    IdentityImageFilter(sk_sp<SkImageFilter> input) : INHERITED(&input, 1, nullptr) {}
+
     typedef SkImageFilter INHERITED;
 };
 
 static IdentityImageFilter::Registrar gReg1;
 
 sk_sp<SkFlattenable> IdentityImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
-    return sk_sp<SkFlattenable>(IdentityImageFilter::Create(common.getInput(0).get()));
+    return IdentityImageFilter::Make(common.getInput(0));
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void IdentityImageFilter::toString(SkString* str) const {
     str->appendf("IdentityImageFilter: (");
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 81 matching lines @@
     }
 
     void onDraw(SkCanvas* canvas) override {
         void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = {
             draw_paint,
             draw_line, draw_rect, draw_path, draw_text,
             draw_bitmap,
         };
 
         auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode);
         SkImageFilter* filters[] = {

[reed1, 2016/04/03 21:29:24]

at some point we should convert this over to an array of sk_sp

[robertphillips, 2016/04/04 11:46:22]

Acknowledged.

             nullptr,
-            IdentityImageFilter::Create(),
-            FailImageFilter::Create(),
+            IdentityImageFilter::Make(nullptr).release(),
+            FailImageFilter::Make().release(),
             SkColorFilterImageFilter::Create(cf.get()),
             SkBlurImageFilter::Create(12.0f, 0.0f),
             SkDropShadowImageFilter::Create(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
         };
 
         SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
         SkScalar MARGIN = SkIntToScalar(16);
         SkScalar DX = r.width() + MARGIN;
         SkScalar DY = r.height() + MARGIN;
@@ skipping 105 matching lines @@
 
 class ImageFiltersText_CF : public ImageFiltersTextBaseGM {
 public:
     ImageFiltersText_CF() : ImageFiltersTextBaseGM("color") {}
 
     void installFilter(SkPaint* paint) override {
         paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
     }
 };
 DEF_GM( return new ImageFiltersText_CF; )