Apply coverage in XP base class when using dst reads

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
 
@@ skipping 72 matching lines @@
  * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
  * required after a pixel has been written, before it can be safely read again.
  */
 enum GrXferBarrierType {
     kTexture_GrXferBarrierType, //<! Required when a shader reads and renders to the same texture.
     kBlend_GrXferBarrierType,   //<! Required by certain blend extensions.
 };
 
 /**
  * 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.
+ * color, and for applying any coverage. It does this by emitting fragment shader code and
+ * controlling the fixed-function blend state. When dual-source blending is available, it may also
+ * write a seconday fragment shader output color. GrXferProcessor has two modes of operation:
+ *
+ * Dst read: When allowed by the backend API, or when supplied a texture of the destination, the
+ * GrXferProcessor may read the destination color. While operating in this mode, the subclass only
+ * provides shader code that blends the src and dst colors, and the base class applies coverage.
+ *
+ * No dst read: When not performing a dst read, the subclass is given full control of the fixed-
+ * function blend state and/or secondary output, and is responsible to apply coverage on its own.
  *
  * 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 GrProcessor {
 public:
     /**
      * A texture that contains the dst pixel values and an integer coord offset from device space
      * to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
      * GrXferProcessor for blending in the fragment shader.
@@ skipping 111 matching lines @@
 
         SkDEBUGCODE(SkString dump() const;)
 
         GrBlendEquation fEquation;
         GrBlendCoeff    fSrcBlend;
         GrBlendCoeff    fDstBlend;
         GrColor         fBlendConstant;
         bool            fWriteColor;
     };
 
-    void getBlendInfo(BlendInfo* blendInfo) const {
-        blendInfo->reset();
-        this->onGetBlendInfo(blendInfo);
-    }
+    void getBlendInfo(BlendInfo* blendInfo) const;
 
     bool willReadDstColor() const { return fWillReadDstColor; }
 
     /**
      * Returns the texture to be used as the destination when reading the dst in the fragment
      * shader. If the returned texture is NULL then the XP is either not reading the dst or we have
      * extentions that support framebuffer fetching and thus don't need a copy of the dst texture.
      */
     const GrTexture* getDstTexture() const { return fDstTexture.getTexture(); }
 
     /**
      * Returns the offset in device coords to use when accessing the dst texture to get the dst
      * pixel color in the shader. This value is only valid if getDstTexture() != NULL.
      */
     const SkIPoint& dstTextureOffset() const {
         SkASSERT(this->getDstTexture());
         return fDstTextureOffset;
     }
 
     /**
      * Returns whether or not the XP will look at coverage when doing its blending.
      */
     bool readsCoverage() const { return fReadsCoverage; }
 
-    /** 
+    /**
      * Returns whether or not this xferProcossor will set a secondary output to be used with dual
      * source blending.
      */
-    virtual bool hasSecondaryOutput() const { return false; }
+    bool hasSecondaryOutput() const;
 
     /** 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()) {
@@ skipping 36 matching lines @@
      * If not using a texture barrier, retrieves whether the subclass will require a different type
      * of barrier.
      */
     virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
                                        const GrCaps&,
                                        GrXferBarrierType* outBarrierType SK_UNUSED) const {
         return false;
     }
 
     /**
-     * Retrieves the hardware blend state required by this Xfer processor. The BlendInfo struct
-     * comes initialized to default values, so the Xfer processor only needs to set the state it
-     * needs. It may not even need to override this method at all.
+     * If we are not performing a dst read, returns whether the subclass will set a secondary
+     * output. When using dst reads, the base class disables the secondary output and this method
+     * will not be called.
+     */
+    virtual bool onHasSecondaryOutput() const { return false; }
+
+    /**
+     * If we are not performing a dst read, retrieves the fixed-function blend state required by the
+     * subclass. When using dst reads, the base class disables fixed-function blending and this
+     * method will not be called. The BlendInfo struct comes initialized to "no blending".
      */
     virtual void onGetBlendInfo(BlendInfo*) const {}
 
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
     bool                    fWillReadDstColor;
     bool                    fReadsCoverage;
     SkIPoint                fDstTextureOffset;
     GrTextureAccess         fDstTexture;
 
@@ skipping 105 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif