Add SkRasterPipeline blitter.

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 "SkFlattenable.h"
 #include "SkColor.h"
 
 class GrFragmentProcessor;
 class GrTexture;
 class GrXPFactory;
+class SkRasterPipeline;
 class SkString;
 
 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
@@ skipping 130 matching lines @@
 #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;
 
+    bool appendStages(SkRasterPipeline*) 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);
 
     /**
      * Returns whether or not the xfer mode can support treating coverage as alpha
@@ skipping 32 matching lines @@
      *  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. 
+        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;
 
-    /** A subclass must implement this factory function to work with the GPU backend. 
-        The xfermode will return a factory for which the caller will get a ref. It is up 
+    /** A subclass must implement this factory function to work with the GPU backend.
+        The xfermode will return a factory for which the caller will get a ref. It is up
         to the caller to install it. XferProcessors cannot use a background texture.
       */
     virtual sk_sp<GrXPFactory> asXPFactory() const;
 #endif
 
     SK_TO_STRING_PUREVIRT()
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
     SK_DEFINE_FLATTENABLE_TYPE(SkXfermode)
 
     enum D32Flags {
@@ skipping 36 matching lines @@
         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