Add XP to handle the cases where we disable color write.

src/gpu/effects/GrPorterDuffXferProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
-#include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrProcOptInfo.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "gl/GrGLXferProcessor.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 static bool can_tweak_alpha_for_coverage(GrBlendCoeff dstCoeff) {
     /*
@@ skipping 97 matching lines @@
     GrGLPorterDuffXferProcessor::GenKey(*this, caps, b);
 }
 
 GrGLXferProcessor* GrPorterDuffXferProcessor::createGLInstance() const {
     return SkNEW_ARGS(GrGLPorterDuffXferProcessor, (*this));
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::getOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
-                                            bool colorWriteDisabled,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
                                             const GrDrawTargetCaps& caps) {
     GrXferProcessor::OptFlags optFlags;
     // Optimizations when doing RGB Coverage
     if (coveragePOI.isFourChannelOutput()) {
         // We want to force our primary output to be alpha * Coverage, where alpha is the alpha
         // value of the blend the constant. We should already have valid blend coeff's if we are at
         // a point where we have RGB coverage. We don't need any color stages since the known color
         // output is already baked into the blendConstant.
         uint8_t alpha = GrColorUnpackA(fBlendConstant);
         *overrideColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
         optFlags = GrXferProcessor::kOverrideColor_OptFlag;
     } else {
         optFlags = this->internalGetOptimizations(colorPOI,
                                                   coveragePOI,
-                                                  colorWriteDisabled,
                                                   doesStencilWrite);
     }
     this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite(),
                           colorPOI.readsDst() || coveragePOI.readsDst());
     return optFlags;
 }
 
 void GrPorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
                                                 const GrDrawTargetCaps& caps,
                                                 bool hasSolidCoverage, bool readsDst) {
@@ skipping 33 matching lines @@
                    kOne_GrBlendCoeff == fSrcBlend &&
                    kZero_GrBlendCoeff == fDstBlend) {
             fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
         }
     }
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
-                                                    bool colorWriteDisabled,
                                                     bool doesStencilWrite) {
-    if (colorWriteDisabled) {
-        fSrcBlend = kZero_GrBlendCoeff;
-        fDstBlend = kOne_GrBlendCoeff;
-    }
-
     bool srcAIsOne;
     bool hasCoverage;
 
     srcAIsOne = colorPOI.isOpaque();
     hasCoverage = !coveragePOI.isSolidWhite();
 
     bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstBlend ||
                          (kSA_GrBlendCoeff == fDstBlend && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstBlend ||
                          (kISA_GrBlendCoeff == fDstBlend && srcAIsOne);
@@ skipping 174 matching lines @@
 bool GrPorterDuffXPFactory::supportsRGBCoverage(GrColor /*knownColor*/,
                                                 uint32_t knownColorFlags) const {
     if (kOne_GrBlendCoeff == fSrcCoeff && kISA_GrBlendCoeff == fDstCoeff &&
         kRGBA_GrColorComponentFlags == knownColorFlags) {
         return true;
     }
     return false;
 }
 
 bool GrPorterDuffXPFactory::canApplyCoverage(const GrProcOptInfo& colorPOI,
-                                             const GrProcOptInfo& coveragePOI,
-                                             bool colorWriteDisabled) const {
+                                             const GrProcOptInfo& coveragePOI) const {
     bool srcAIsOne = colorPOI.isOpaque();
 
-    if (colorWriteDisabled) {
-        return true;
-    }
-
     bool dstCoeffIsOne = kOne_GrBlendCoeff == fDstCoeff ||
                          (kSA_GrBlendCoeff == fDstCoeff && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == fDstCoeff ||
                          (kISA_GrBlendCoeff == fDstCoeff && srcAIsOne);
 
     if ((kZero_GrBlendCoeff == fSrcCoeff && dstCoeffIsOne)) {
         return true;
     }
 
     // if we don't have coverage we can check whether the dst
@@ skipping 22 matching lines @@
 
     return false;
 }
 
 bool GrPorterDuffXPFactory::canTweakAlphaForCoverage() const {
     return can_tweak_alpha_for_coverage(fDstCoeff);
 }
 
 void GrPorterDuffXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
-                                               bool colorWriteDisabled,
                                                GrXPFactory::InvariantOutput* output) const {
     if (!coveragePOI.isSolidWhite()) {
         output->fWillBlendWithDst = true;
         output->fBlendedColorFlags = 0;
         return;
     }
 
     GrBlendCoeff srcCoeff = fSrcCoeff;
     GrBlendCoeff dstCoeff = fDstCoeff;
 
@@ skipping 46 matching lines @@
         case kConstC_GrBlendCoeff:
         case kIConstC_GrBlendCoeff:
         case kConstA_GrBlendCoeff:
         case kIConstA_GrBlendCoeff:
             output->fBlendedColorFlags = 0;
             break;
     }
 
     // TODO: once all SkXferEffects are XP's then we will never reads dst here since only XP's
     // will readDst and PD XP's don't read dst.
-    if ((!colorWriteDisabled && colorPOI.readsDst()) || coveragePOI.readsDst()) {
+    if (colorPOI.readsDst() || coveragePOI.readsDst()) {
         output->fWillBlendWithDst = true;
         return;
     }
     output->fWillBlendWithDst = false;
 }
 
+bool GrPorterDuffXPFactory::willReadDst(const GrProcOptInfo& colorPOI,
+                                        const GrProcOptInfo& coveragePOI) const {
+    return colorPOI.readsDst() || coveragePOI.readsDst();
+}
+
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrDrawTargetCaps&,
                                                GrTexture*[]) {
     GrBlendCoeff src;
     do {
         src = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsSrc(src));
 
     GrBlendCoeff dst;
     do {
         dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsDst(dst));
 
     return GrPorterDuffXPFactory::Create(src, dst);
 }