Only discard for XP dstCopies if we have a coverage value.

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 146 matching lines @@
 
     /**
      * Determines which optimizations (as described by the ptFlags above) can be performed by
      * the draw with this xfer processor. If this function is called, the xfer processor may change
      * its state to reflected the given blend optimizations. If the XP needs to see a specific input
      * color to blend correctly, it will set the OverrideColor flag and the output parameter
      * overrideColor will be the required value that should be passed into the XP. 
      * A caller who calls this function on a XP is required to honor the returned OptFlags
      * and color values for its draw.
      */
-    virtual OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
-                                      const GrProcOptInfo& coveragePOI,
-                                      bool doesStencilWrite,
-                                      GrColor* overrideColor,
-                                      const GrDrawTargetCaps& caps) = 0;
+    OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
+                              const GrProcOptInfo& coveragePOI,
+                              bool doesStencilWrite,
+                              GrColor* overrideColor,
+                              const GrDrawTargetCaps& caps);
 
     /**
      * Returns whether this XP will require an Xfer barrier on the given rt. If true, outBarrierType
      * is updated to contain the type of barrier needed.
      */
     bool willNeedXferBarrier(const GrRenderTarget* rt,
                              const GrDrawTargetCaps& caps,
                              GrXferBarrierType* outBarrierType) const;
 
     struct BlendInfo {
@@ skipping 28 matching lines @@
 
     /**
      * Returns the offset into the DstCopyTexture to use when reading it in the shader. This value
      * is only valid if getDstCopyTexture() != NULL.
      */
     const SkIPoint& dstCopyTextureOffset() const {
         SkASSERT(this->getDstCopyTexture());
         return fDstCopyTextureOffset;
     }
 
+    /**
+     * 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; }
 
     /** 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;
         }
         if (this->fWillReadDstColor != that.fWillReadDstColor) {
             return false;
         }
+        if (this->fReadsCoverage != that.fReadsCoverage) {
+            return false;
+        }
         if (this->fDstCopy.getTexture() != that.fDstCopy.getTexture()) {
             return false;
         }
         if (this->fDstCopyTextureOffset != that.fDstCopyTextureOffset) {
             return false;
         }
         return this->onIsEqual(that);
     }
    
 protected:
     GrXferProcessor();
     GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
 private:
+    virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
+                                        const GrProcOptInfo& coveragePOI,
+                                        bool doesStencilWrite,
+                                        GrColor* overrideColor,
+                                        const GrDrawTargetCaps& caps) = 0;
+
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
      * processor's GL backend implementation.
      */
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const = 0;
 
     /**
      * If not using a texture barrier, retrieves whether the subclass will require a different type
      * of barrier.
      */
     virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
                                        const GrDrawTargetCaps&,
                                        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.
      */
     virtual void onGetBlendInfo(BlendInfo*) const {}
 
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
     bool                    fWillReadDstColor;
+    bool                    fReadsCoverage;
     SkIPoint                fDstCopyTextureOffset;
     GrTextureAccess         fDstCopy;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 93 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif