Revert[8] "replace SkXfermode obj with SkBlendMode enum in paints"

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
 #define SkXfermode_DEFINED
 
+#include "SkBlendMode.h"
+#include "SkColor.h"
 #include "SkFlattenable.h"
-#include "SkColor.h"
 
 class GrFragmentProcessor;
 class GrTexture;
 class GrXPFactory;
 class SkRasterPipeline;
 class SkString;
 
+struct SkArithmeticParams;
+
 struct SkPM4f;
 typedef SkPM4f (*SkXfermodeProc4f)(const SkPM4f& src, const SkPM4f& dst);
 
 /** \class SkXfermode
  *
  *  SkXfermode is the base class for objects that are called to implement custom
  *  "transfer-modes" in the drawing pipeline. The static function Create(Modes)
  *  can be called to return an instance of any of the predefined subclasses as
  *  specified in the Modes enum. When an SkXfermode is assigned to an SkPaint,
  *  then objects drawn with that paint have the xfermode applied.
@@ skipping 75 matching lines @@
         kSaturation_Mode,
         kColor_Mode,
         kLuminosity_Mode,
         kLastMode = kLuminosity_Mode
     };
 
     /**
      * Gets the name of the Mode as a string.
      */
     static const char* ModeName(Mode);
+    static const char* ModeName(SkBlendMode mode) {
+        return ModeName(Mode(mode));
+    }
 
     /**
      *  If the xfermode is one of the modes in the Mode enum, then asMode()
      *  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
@@ skipping 25 matching lines @@
 #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
 
+    /**
+     *  Skia maintains global xfermode objects corresponding to each BlendMode. This returns a
+     *  ptr to that global xfermode (or null if the mode is srcover). Thus the caller may use
+     *  the returned ptr, but it should leave its refcnt untouched.
+     */
+    static SkXfermode* Peek(SkBlendMode mode) {
+        sk_sp<SkXfermode> xfer = Make(mode);
+        if (!xfer) {
+            SkASSERT(SkBlendMode::kSrcOver == mode);
+            return nullptr;
+        }
+        SkASSERT(!xfer->unique());
+        return xfer.get();
+    }
+
+    static sk_sp<SkXfermode> Make(SkBlendMode bm) {
+        return Make((Mode)bm);
+    }
+
+    SkBlendMode blend() const {
+        Mode mode;
+        SkAssertResult(this->asMode(&mode));
+        return (SkBlendMode)mode;
+    }
+
     /** 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;
 
     bool appendStages(SkRasterPipeline*) const;
 
@@ skipping 38 matching lines @@
     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);
     }
+    static bool IsOpaque(SkBlendMode, SrcColorOpacity);
 
 #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 sk_sp<GrFragmentProcessor> makeFragmentProcessorForImageFilter(
                                                             sk_sp<GrFragmentProcessor> dst) const;
@@ skipping 35 matching lines @@
     enum LCDFlags {
         kSrcIsOpaque_LCDFlag    = 1 << 0,   // else src(s) may have alpha < 1
         kSrcIsSingle_LCDFlag    = 1 << 1,   // else src[count]
         kDstIsSRGB_LCDFlag      = 1 << 2,   // else l32 or f16
     };
     typedef void (*LCD32Proc)(uint32_t* dst, const SkPM4f* src, int count, const uint16_t lcd[]);
     typedef void (*LCDF16Proc)(uint64_t* dst, const SkPM4f* src, int count, const uint16_t lcd[]);
     static LCD32Proc GetLCD32Proc(uint32_t flags);
     static LCDF16Proc GetLCDF16Proc(uint32_t) { return nullptr; }
 
+    virtual bool isArithmetic(SkArithmeticParams*) const { return false; }
+
 protected:
     SkXfermode() {}
     /** The default implementation of xfer32/xfer16/xferA8 in turn call this
         method, 1 color at a time (upscaled to a SkPMColor). The default
         implementation of this method just returns dst. If performance is
         important, your subclass should override xfer32/xfer16/xferA8 directly.
 
         This method will not be called directly by the client, so it need not
         be implemented if your subclass has overridden xfer32/xfer16/xferA8
     */
     virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;
 
     virtual D32Proc onGetD32Proc(uint32_t flags) const;
     virtual F16Proc onGetF16Proc(uint32_t flags) const;
     virtual bool onAppendStages(SkRasterPipeline*) const;
 
 private:
     enum {
         kModeCount = kLastMode + 1
     };
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif