Revert of switch patheffects over to sk_sp

gm/dashing.cpp

 /*
  * Copyright 2012 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 "SkPaint.h"
 #include "SkDashPathEffect.h"
 
 static void drawline(SkCanvas* canvas, int on, int off, const SkPaint& paint,
                      SkScalar finalX = SkIntToScalar(600), SkScalar finalY = SkIntToScalar(0),
                      SkScalar phase = SkIntToScalar(0), 
                      SkScalar startX = SkIntToScalar(0), SkScalar startY = SkIntToScalar(0)) {
     SkPaint p(paint);
 
     const SkScalar intervals[] = {
         SkIntToScalar(on),
         SkIntToScalar(off),
     };
 
-    p.setPathEffect(SkDashPathEffect::Make(intervals, 2, phase));
+    SkAutoTUnref<SkPathEffect> effect(SkDashPathEffect::Create(intervals, 2, phase));
+    p.setPathEffect(effect);
     canvas->drawLine(startX, startY, finalX, finalY, p);
 }
 
 // earlier bug stopped us from drawing very long single-segment dashes, because
 // SkPathMeasure was skipping very small delta-T values (nearlyzero). This is
 // now fixes, so this giant dash should appear.
 static void show_giant_dash(SkCanvas* canvas) {
     SkPaint paint;
 
     drawline(canvas, 1, 1, paint, SkIntToScalar(20 * 1000));
@@ skipping 132 matching lines @@
         SkScalar dy = bounds.height() * 4 / 3;
 
         const int* intervals = &gIntervals[1];
         for (int y = 0; y < gIntervals[0]; ++y) {
             SkScalar vals[SK_ARRAY_COUNT(gIntervals)];  // more than enough
             int count = *intervals++;
             for (int i = 0; i < count; ++i) {
                 vals[i] = SkIntToScalar(*intervals++);
             }
             SkScalar phase = vals[0] / 2;
-            paint.setPathEffect(SkDashPathEffect::Make(vals, count, phase));
+            paint.setPathEffect(SkDashPathEffect::Create(vals, count, phase))->unref();
 
             for (size_t x = 0; x < SK_ARRAY_COUNT(gProc); ++x) {
                 SkPath path;
                 SkRect r = bounds;
                 r.offset(x * dx, y * dy);
                 gProc[x](&path, r);
 
                 canvas->drawPath(path, paint);
             }
         }
@@ skipping 27 matching lines @@
         p.setColor(SK_ColorBLACK);
         p.setStyle(SkPaint::kStroke_Style);
         p.setStrokeWidth(SkIntToScalar(strokeWidth));
 
         if (circles) {
             p.setStrokeCap(SkPaint::kRound_Cap);
         }
 
         SkScalar intervals[2] = { dashLength, dashLength };
 
-        p.setPathEffect(SkDashPathEffect::Make(intervals, 2, phase));
+        p.setPathEffect(SkDashPathEffect::Create(intervals, 2, phase))->unref();
 
         SkPoint pts[2];
 
         for (int y = 0; y < 100; y += 10*strokeWidth) {
             pts[0].set(0, SkIntToScalar(y));
             pts[1].set(lineLength, SkIntToScalar(y));
 
             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
         }
 
@@ skipping 255 matching lines @@
                 lines.lineTo(pts[0].fX * (1 - i) + pts[1].fX * i,
                              pts[0].fY * (1 - i) + pts[1].fY * i);
             }
         }
     }
     SkPaint p;
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(1);
     const SkScalar intervals[] = { 1, 1 };
-    p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
+    p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref();
     canvas->drawPath(lines, p);
 }
 
 DEF_SIMPLE_GM(longlinedash, canvas, 512, 512) {
     SkPaint p;
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(80);
 
     const SkScalar intervals[] = { 2, 2 };
-    p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
+    p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref();
     canvas->drawRect(SkRect::MakeXYWH(-10000, 100, 20000, 20), p);
 }
 
 DEF_SIMPLE_GM(longwavyline, canvas, 512, 512) {
     SkPaint p;
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(2);
 
     SkPath wavy;
     wavy.moveTo(-10000, 100);
     for (SkScalar i = -10000; i < 10000; i += 20) {
         wavy.quadTo(i + 5, 95, i + 10, 100);
         wavy.quadTo(i + 15, 105, i + 20, 100);
     }
     canvas->drawPath(wavy, p);
 }
 
 DEF_SIMPLE_GM(dashtextcaps, canvas, 512, 512) {
     SkPaint p;
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(10);
     p.setStrokeCap(SkPaint::kRound_Cap);
     p.setStrokeJoin(SkPaint::kRound_Join);
     p.setTextSize(100);
     p.setARGB(0xff, 0xbb, 0x00, 0x00);
     sk_tool_utils::set_portable_typeface(&p);
     const SkScalar intervals[] = { 12, 12 };
-    p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
+    p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref();
     canvas->drawText("Sausages", 8, 10, 90, p);
     canvas->drawLine(8, 120, 456, 120, p);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new DashingGM;)
 DEF_GM(return new Dashing2GM;)
 DEF_GM(return new Dashing3GM;)
 DEF_GM(return new Dashing4GM;)
 DEF_GM(return new Dashing5GM(true);)
 DEF_GM(return new Dashing5GM(false);)