switch xfermodes over to sk_sp

include/core/SkXfermode.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkXfermode_DEFINED
@@ skipping 108 matching lines @@
      *  returns true and sets (if not null) mode accordingly. Otherwise it
      *  returns false and ignores the mode parameter.
      */
     virtual bool asMode(Mode* mode) const;
 
     /**
      *  The same as calling xfermode->asMode(mode), except that this also checks
      *  if the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
      */
     static bool AsMode(const SkXfermode*, Mode* mode);
+    static bool AsMode(const sk_sp<SkXfermode>& xfer, Mode* mode) {
+        return AsMode(xfer.get(), mode);
+    }
 
     /**
      *  Returns true if the xfermode claims to be the specified Mode. This works
      *  correctly even if the xfermode is NULL (which equates to kSrcOver.) Thus
      *  you can say this without checking for a null...
      *
      *  If (SkXfermode::IsMode(paint.getXfermode(),
      *                         SkXfermode::kDstOver_Mode)) {
      *      ...
      *  }
      */
     static bool IsMode(const SkXfermode* xfer, Mode mode);
+    static bool IsMode(const sk_sp<SkXfermode>& xfer, Mode mode) {
+        return IsMode(xfer.get(), mode);
+    }
 
     /** Return an SkXfermode object for the specified mode.
      */
-    static SkXfermode* Create(Mode mode);
+    static sk_sp<SkXfermode> Make(Mode);
+#ifdef SK_SUPPORT_LEGACY_XFERMODE_PTR
+    static SkXfermode* Create(Mode mode) {
+        return Make(mode).release();
+    }
+    SK_ATTR_DEPRECATED("use AsMode(...)")
+    static bool IsMode(const SkXfermode* xfer, Mode* mode) {
+        return AsMode(xfer, mode);
+    }
+#endif
 
     /** Return a function pointer to a routine that applies the specified
         porter-duff transfer mode.
      */
     static SkXfermodeProc GetProc(Mode mode);
     static SkXfermodeProc4f GetProc4f(Mode);
 
     virtual SkXfermodeProc4f getProc4f() const;
 
     /**
      *  If the specified mode can be represented by a pair of Coeff, then return
      *  true and set (if not NULL) the corresponding coeffs. If the mode is
      *  not representable as a pair of Coeffs, return false and ignore the
      *  src and dst parameters.
      */
     static bool ModeAsCoeff(Mode mode, Coeff* src, Coeff* dst);
 
-    SK_ATTR_DEPRECATED("use AsMode(...)")
-    static bool IsMode(const SkXfermode* xfer, Mode* mode) {
-        return AsMode(xfer, mode);
-    }
-
     /**
      * Returns whether or not the xfer mode can support treating coverage as alpha
      */
     virtual bool supportsCoverageAsAlpha() const;
 
     /**
      *  The same as calling xfermode->supportsCoverageAsAlpha(), except that this also checks if
      *  the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
      */
     static bool SupportsCoverageAsAlpha(const SkXfermode* xfer);
+    static bool SupportsCoverageAsAlpha(const sk_sp<SkXfermode>& xfer) {
+        return SupportsCoverageAsAlpha(xfer.get());
+    }
 
     enum SrcColorOpacity {
         // The src color is known to be opaque (alpha == 255)
         kOpaque_SrcColorOpacity = 0,
         // The src color is known to be fully transparent (color == 0)
         kTransparentBlack_SrcColorOpacity = 1,
         // The src alpha is known to be fully transparent (alpha == 0)
         kTransparentAlpha_SrcColorOpacity = 2,
         // The src color opacity is unknown
         kUnknown_SrcColorOpacity = 3
     };
 
     /**
      * Returns whether or not the result of the draw with the xfer mode will be opaque or not. The
      * input to this call is an enum describing known information about the opacity of the src color
      * that will be given to the xfer mode.
      */
     virtual bool isOpaque(SrcColorOpacity opacityType) const;
 
     /**
      *  The same as calling xfermode->isOpaque(...), except that this also checks if
      *  the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
      */
     static bool IsOpaque(const SkXfermode* xfer, SrcColorOpacity opacityType);
+    static bool IsOpaque(const sk_sp<SkXfermode>& xfer, SrcColorOpacity opacityType) {
+        return IsOpaque(xfer.get(), opacityType);
+    }
 
 #if SK_SUPPORT_GPU
     /** Used by the SkXfermodeImageFilter to blend two colors via a GrFragmentProcessor.
         The input to the returned FP is the src color. The dst color is
         provided by the dst param which becomes a child FP of the returned FP. 
         It is legal for the function to return a null output. This indicates that
         the output of the blend is simply the src color.
      */
     virtual const GrFragmentProcessor* getFragmentProcessorForImageFilter(
                                                             const GrFragmentProcessor* dst) const;
@@ skipping 10 matching lines @@
     SK_DEFINE_FLATTENABLE_TYPE(SkXfermode)
 
     enum D32Flags {
         kSrcIsOpaque_D32Flag  = 1 << 0,
         kSrcIsSingle_D32Flag  = 1 << 1,
         kDstIsSRGB_D32Flag    = 1 << 2,
     };
     typedef void (*D32Proc)(const SkXfermode*, uint32_t dst[], const SkPM4f src[],
                             int count, const SkAlpha coverage[]);
     static D32Proc GetD32Proc(SkXfermode*, uint32_t flags);
+    static D32Proc GetD32Proc(const sk_sp<SkXfermode>& xfer, uint32_t flags) {
+        return GetD32Proc(xfer.get(), flags);
+    }
 
     enum D64Flags {
         kSrcIsOpaque_D64Flag  = 1 << 0,
         kSrcIsSingle_D64Flag  = 1 << 1,
         kDstIsFloat16_D64Flag = 1 << 2, // else U16 bit components
     };
     typedef void (*D64Proc)(const SkXfermode*, uint64_t dst[], const SkPM4f src[], int count,
                             const SkAlpha coverage[]);
     static D64Proc GetD64Proc(SkXfermode*, uint32_t flags);
+    static D64Proc GetD64Proc(const sk_sp<SkXfermode>& xfer, uint32_t flags) {
+        return GetD64Proc(xfer.get(), flags);
+    }
 
     enum LCDFlags {
         kSrcIsOpaque_LCDFlag    = 1 << 0,   // else src(s) may have alpha < 1
         kSrcIsSingle_LCDFlag    = 1 << 1,   // else src[count]
         kDstIsLinearInt_LCDFlag = 1 << 2,   // else srgb/half-float
     };
     typedef void (*LCD32Proc)(uint32_t* dst, const SkPM4f* src, int count, const uint16_t lcd[]);
     typedef void (*LCD64Proc)(uint64_t* dst, const SkPM4f* src, int count, const uint16_t lcd[]);
     static LCD32Proc GetLCD32Proc(uint32_t flags);
     static LCD64Proc GetLCD64Proc(uint32_t) { return nullptr; }
@@ skipping 15 matching lines @@
 
 private:
     enum {
         kModeCount = kLastMode + 1
     };
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif