Create xfer processor backend.

include/gpu/GrXferProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrXferProcessor_DEFINED
 #define GrXferProcessor_DEFINED
 
 #include "GrColor.h"
-#include "GrFragmentProcessor.h"
+#include "GrProcessor.h"
 #include "GrTypes.h"
 #include "SkXfermode.h"
 
+class GrDrawTargetCaps;
+class GrGLCaps;
+class GrGLXferProcessor;
 class GrProcOptInfo;
 
 /**
  * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
  * color. It does this by emitting fragment shader code and controlling the fixed-function blend
  * state. The inputs to its shader code are the final computed src color and fractional pixel
  * coverage. The GrXferProcessor's shader code writes the fragment shader output color that goes
  * into the fixed-function blend. When dual-source blending is available, it may also write a
  * seconday fragment shader output color. When allowed by the backend API, the GrXferProcessor may
  * read the destination color. The GrXferProcessor is responsible for setting the blend coefficients
  * and blend constant color.
  *
  * A GrXferProcessor is never installed directly into our draw state, but instead is created from a
  * GrXPFactory once we have finalized the state of our draw.
  */
-class GrXferProcessor : public GrFragmentProcessor {
+class GrXferProcessor : public GrProcessor {
 public:
     /**
+     * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
+     * processor's GL backend implementation.
+     */
+    virtual void getGLProcessorKey(const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const = 0;
+
+    /** Returns a new instance of the appropriate *GL* implementation class
+        for the given GrXferProcessor; caller is responsible for deleting
+        the object. */
+    virtual GrGLXferProcessor* createGLInstance() const = 0;
+
+    /**
      * Optimizations for blending / coverage that an OptDrawState should apply to itself.
      */
     enum OptFlags {
         /**
          * No optimizations needed
          */
         kNone_Opt                         = 0,
         /**
          * The draw can be skipped completely.
          */
@@ skipping 23 matching lines @@
      * and color/coverage values for its draw.
      */
     // TODO: remove need for isCoverageDrawing once coverageDrawing is its own XP.
     // TODO: remove need for colorWriteDisabled once colorWriteDisabled is its own XP.
     virtual OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                                       const GrProcOptInfo& coveragePOI,
                                       bool isCoverageDrawing,
                                       bool colorWriteDisabled,
                                       bool doesStencilWrite,
                                       GrColor* color,
-                                      uint8_t* coverage) = 0;
+                                      uint8_t* coverage,
+                                      const GrDrawTargetCaps& caps) = 0;
 
     struct BlendInfo {
         GrBlendCoeff fSrcBlend;
         GrBlendCoeff fDstBlend;
         GrColor      fBlendConstant;
     };
 
     virtual void getBlendInfo(BlendInfo* blendInfo) const = 0;
 
     /** Will this prceossor read the destination pixel value? */
     bool willReadDstColor() const { return fWillReadDstColor; }
 
+    /** 
+     * Returns whether or not this xferProcossor will set a secondary output to be used with dual
+     * source blending.
+     */
+    virtual bool hasSecondaryOutput() const { return false; }
+
+    /** Returns true if this and other processor conservatively draw identically. It can only return
+        true when the two processor are of the same subclass (i.e. they return the same object from
+        from getFactory()).
+
+        A return value of true from isEqual() should not be used to test whether the processor would
+        generate the same shader code. To test for identical code generation use getGLProcessorKey*/
+    
+    bool isEqual(const GrXferProcessor& that) const {
+        if (this->classID() != that.classID()) {
+            return false;
+        }
+        return this->onIsEqual(that);
+    }
+   
+
 protected:
     GrXferProcessor() : fWillReadDstColor(false) {}
 
     /**
      * If the prceossor subclass will read the destination pixel value then it must call this
      * function from its constructor. Otherwise, when its generated backend-specific prceossor class
      * attempts to generate code that reads the destination pixel it will fail.
      */
     void setWillReadDstColor() { fWillReadDstColor = true; }
 
 private:
+    virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
     bool         fWillReadDstColor;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
 
 /**
  * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is
@@ skipping 94 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif