Create fragment processor for performing input color blend with child processor

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 176 matching lines @@
      * 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.
+    /** Used to do in-shader blending between two colors computed in the shader 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. If the params are
+        null then this is just a query of whether the SkXfermode could support this functionality.
+        It is legal for the function to succeed but return a null output. This indicates that
+        the output of the blend is simply the src color.
      */
-    virtual bool asFragmentProcessor(GrFragmentProcessor**, GrProcessorDataManager*,
-                                     GrTexture* background) const;
+    virtual bool asFragmentProcessor(const GrFragmentProcessor** output, GrProcessorDataManager*,
+                                     const GrFragmentProcessor* dst) const;
 
     /** A subclass may implement this factory function to work with the GPU backend. It is legal
         to call this with xpf NULL to simply test the return value. If xpf is non-NULL then the
         xfermode may optionally allocate a factory to return to the caller as *xpf. The caller
         will install it and own a ref to it. Since the xfermode may or may not assign *xpf, the
         caller should set *xpf to NULL beforehand. XferProcessors cannot use a background texture.
      */
     virtual bool asXPFactory(GrXPFactory** xpf) const;
 
     /** Returns true if the xfermode can be expressed as an xfer processor factory (xpFactory).
         This helper calls the asXPFactory() virtual. If the xfermode is NULL, it is treated as
         kSrcOver_Mode. It is legal to call this with xpf param NULL to simply test the return value.
      */
     static bool AsXPFactory(SkXfermode*, GrXPFactory**);
 
     SK_TO_STRING_PUREVIRT()
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
     SK_DEFINE_FLATTENABLE_TYPE(SkXfermode)
 
 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
-        implmentation of this method just returns dst. If performance is
+        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;
 
 private:
     enum {
         kModeCount = kLastMode + 1
     };
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif