switch xfermodes over to sk_sp

gm/xfermodes.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 "SkBitmap.h"
 #include "SkShader.h"
 #include "SkXfermode.h"
 #include "SkPM4f.h"
 
 #include "SkArithmeticMode.h"
 #include "SkPixelXorXfermode.h"
 #include "SkAvoidXfermode.h"
 
 #define kCustomShift    16
 #define kCustomMask     (~0xFFFF)
 
 enum CustomModes {
     kArithmetic_CustomMode  = 1 << kCustomShift,
     kPixelXor_CustomMode    = 2 << kCustomShift,
     kAvoid_CustomMode       = 3 << kCustomShift,
 };
 
-static SkXfermode* make_custom(int customMode) {
+static sk_sp<SkXfermode> make_custom(int customMode) {
     switch (customMode) {
         case kArithmetic_CustomMode: {
             const SkScalar k1 = 0.25;
             const SkScalar k2 = 0.75;
             const SkScalar k3 = 0.75;
             const SkScalar k4 = -0.25;
-            return SkArithmeticMode::Create(k1, k2, k3, k4);
+            return SkArithmeticMode::Make(k1, k2, k3, k4);
         }
         case kPixelXor_CustomMode:
-            return SkPixelXorXfermode::Create(0xFF88CC44);
+            return SkPixelXorXfermode::Make(0xFF88CC44);
         case kAvoid_CustomMode:
-            return SkAvoidXfermode::Create(0xFFFF0000, 0x44, SkAvoidXfermode::kAvoidColor_Mode);
+            return SkAvoidXfermode::Make(0xFFFF0000, 0x44, SkAvoidXfermode::kAvoidColor_Mode);
         default:
             break;
     }
     SkASSERT(false);
     return nullptr;
 }
 
 enum SrcType {
     //! A WxH image with a rectangle in the lower right.
     kRectangleImage_SrcType               = 0x01,
@@ skipping 98 matching lines @@
 static uint16_t gData[] = { 0xFFFF, 0xCCCF, 0xCCCF, 0xFFFF };
 
 class XfermodesGM : public skiagm::GM {
     SkBitmap    fBG;
     SkBitmap    fSrcB, fDstB, fTransparent;
 
     /* The srcType argument indicates what to draw for the source part. Skia
      * uses the implied shape of the drawing command and these modes
      * demonstrate that.
      */
-    void draw_mode(SkCanvas* canvas, SkXfermode* mode, SrcType srcType,
+    void draw_mode(SkCanvas* canvas, sk_sp<SkXfermode> mode, SrcType srcType,
                    SkScalar x, SkScalar y) {
         SkPaint p;
         SkMatrix m;
         bool restoreNeeded = false;
         m.setTranslate(x, y);
 
         canvas->drawBitmap(fSrcB, x, y, &p);
-        p.setXfermode(mode);
+        p.setXfermode(std::move(mode));
         switch (srcType) {
             case kSmallTransparentImage_SrcType: {
                 m.postScale(SK_ScalarHalf, SK_ScalarHalf, x, y);
 
                 SkAutoCanvasRestore acr(canvas, true);
                 canvas->concat(m);
                 canvas->drawBitmap(fTransparent, 0, 0, &p);
                 break;
             }
             case kQuarterClearInLayer_SrcType: {
@@ skipping 95 matching lines @@
         const int W = 5;
 
         SkScalar x0 = 0;
         SkScalar y0 = 0;
         for (int sourceType = 1; sourceType & kAll_SrcType; sourceType <<= 1) {
             SkScalar x = x0, y = y0;
             for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
                 if ((gModes[i].fSourceTypeMask & sourceType) == 0) {
                     continue;
                 }
-                SkAutoTUnref<SkXfermode> mode;
+                sk_sp<SkXfermode> mode;
                 if (gModes[i].fSourceTypeMask & kCustomMask) {
-                    mode.reset(make_custom(gModes[i].fSourceTypeMask & kCustomMask));
+                    mode = make_custom(gModes[i].fSourceTypeMask & kCustomMask);
                 } else {
-                    mode.reset(SkXfermode::Create(gModes[i].fMode));
+                    mode = SkXfermode::Make(gModes[i].fMode);
                 }
                 SkRect r;
                 r.set(x, y, x+w, y+h);
 
                 SkPaint p;
                 p.setStyle(SkPaint::kFill_Style);
                 p.setShader(s);
                 canvas->drawRect(r, p);
 
                 canvas->saveLayer(&r, nullptr);
-                draw_mode(canvas, mode, static_cast<SrcType>(sourceType),
+                draw_mode(canvas, std::move(mode), static_cast<SrcType>(sourceType),
                           r.fLeft, r.fTop);
                 canvas->restore();
 
                 r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
                 p.setStyle(SkPaint::kStroke_Style);
                 p.setShader(nullptr);
                 canvas->drawRect(r, p);
 
 #if 1
                 canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
@@ skipping 14 matching lines @@
                 x0 += SkIntToScalar(400);
                 y0 = 0;
             }
         }
     }
 
 private:
     typedef GM INHERITED;
 };
 DEF_GM( return new XfermodesGM; )