Revert of switch patheffects over to sk_sp

samplecode/SampleFilterFuzz.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 "SampleCode.h"
 #include "Sk1DPathEffect.h"
 #include "Sk2DPathEffect.h"
 #include "SkAlphaThresholdFilter.h"
@@ skipping 404 matching lines @@
             default:
                 path.arcTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
                 break;
 
         }
     }
     path.close();
     return path;
 }
 
-static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) {
-    sk_sp<SkPathEffect> pathEffect;
+static SkPathEffect* make_path_effect(bool canBeNull = true) {
+    SkPathEffect* pathEffect = nullptr;
     if (canBeNull && (R(3) == 1)) { return pathEffect; }
 
     switch (R(9)) {
         case 0:
-            pathEffect = SkArcToPathEffect::Make(make_scalar(true));
+            pathEffect = SkArcToPathEffect::Create(make_scalar(true));
             break;
-        case 1:
-            pathEffect = SkComposePathEffect::Make(make_path_effect(false),
-                                                   make_path_effect(false));
+        case 1: {
+            SkAutoTUnref<SkPathEffect> outer(make_path_effect(false));
+            SkAutoTUnref<SkPathEffect> inner(make_path_effect(false));
+            pathEffect = SkComposePathEffect::Create(outer, inner);
             break;
+        }
         case 2:
-            pathEffect = SkCornerPathEffect::Make(make_scalar());
+            pathEffect = SkCornerPathEffect::Create(make_scalar());
             break;
         case 3: {
             int count = R(10);
             SkScalar intervals[10];
             for (int i = 0; i < count; ++i) {
                 intervals[i] = make_scalar();
             }
-            pathEffect = SkDashPathEffect::Make(intervals, count, make_scalar());
+            pathEffect = SkDashPathEffect::Create(intervals, count, make_scalar());
             break;
         }
         case 4:
-            pathEffect = SkDiscretePathEffect::Make(make_scalar(), make_scalar());
+            pathEffect = SkDiscretePathEffect::Create(make_scalar(), make_scalar());
             break;
         case 5:
-            pathEffect = SkPath1DPathEffect::Make(make_path(), make_scalar(), make_scalar(),
-                                                  make_path_1d_path_effect_style());
+            pathEffect = SkPath1DPathEffect::Create(make_path(),
+                                                    make_scalar(),
+                                                    make_scalar(),
+                                                    make_path_1d_path_effect_style());
             break;
         case 6:
-            pathEffect = SkLine2DPathEffect::Make(make_scalar(), make_matrix());
+            pathEffect = SkLine2DPathEffect::Create(make_scalar(), make_matrix());
             break;
         case 7:
-            pathEffect = SkPath2DPathEffect::Make(make_matrix(), make_path());
+            pathEffect = SkPath2DPathEffect::Create(make_matrix(), make_path());
             break;
         case 8:
         default:
-            pathEffect = SkSumPathEffect::Make(make_path_effect(false),
-                                               make_path_effect(false));
+            pathEffect = SkSumPathEffect::Create(make_path_effect(false),
+                                                 make_path_effect(false));
             break;
     }
     return pathEffect;
 }
 
 static SkMaskFilter* make_mask_filter() {
     SkMaskFilter* maskFilter;
     switch (R(3)) {
         case 0:
             maskFilter = SkBlurMaskFilter::Create(make_blur_style(),
@@ skipping 337 matching lines @@
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new ImageFilterFuzzView; }
 static SkViewRegister reg(MyFactory);