Remove the need for asCoeff in SkXfermode.

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 39 matching lines @@
         kDC_Coeff,      /** dst color */
         kIDC_Coeff,     /** inverse dst color (i.e. 1 - dc) */
         kSA_Coeff,      /** src alpha */
         kISA_Coeff,     /** inverse src alpha (i.e. 1 - sa) */
         kDA_Coeff,      /** dst alpha */
         kIDA_Coeff,     /** inverse dst alpha (i.e. 1 - da) */
 
         kCoeffCount
     };
 
-    /** If the xfermode can be expressed as an equation using the coefficients
-        in Coeff, then asCoeff() returns true, and sets (if not null) src and
-        dst accordingly.
-
-            result = src_coeff * src_color + dst_coeff * dst_color;
-
-        As examples, here are some of the porterduff coefficients
-
-        MODE        SRC_COEFF       DST_COEFF
-        clear       zero            zero
-        src         one             zero
-        dst         zero            one
-        srcover     one             isa
-        dstover     ida             one
-     */
-    virtual bool asCoeff(Coeff* src, Coeff* dst) const;
-
-    /**
-     *  The same as calling xfermode->asCoeff(..), except that this also checks
-     *  if the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
-     */
-    static bool AsCoeff(const SkXfermode*, Coeff* src, Coeff* dst);
-
     /** List of predefined xfermodes.
         The algebra for the modes uses the following symbols:
         Sa, Sc  - source alpha and color
         Da, Dc - destination alpha and color (before compositing)
         [a, c] - Resulting (alpha, color) values
         For these equations, the colors are in premultiplied state.
         If no xfermode is specified, kSrcOver is assumed.
         The modes are ordered by those that can be expressed as a pair of Coeffs, followed by those
         that aren't Coeffs but have separable r,g,b computations, and finally
         those that are not separable.
@@ skipping 90 matching lines @@
      *  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);
+
+    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);
+
     /** Implemented by a subclass to support use as an image filter in the GPU backend. When used as
         an image filter the xfer mode blends the source color against a background texture rather
         than the destination. It is implemented as a fragment processor. This can be called with
         both params set to NULL to query whether it would succeed. Otherwise, both params are
         required. Upon success the function returns true and the caller owns a ref to the fragment
         parameter. Upon failure false is returned and the processor param is not written to.
      */
     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture* background) const;
 
     /** A subclass may implement this factory function to work with the GPU backend. It is legal
@@ skipping 28 matching lines @@
 
 private:
     enum {
         kModeCount = kLastMode + 1
     };
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif