Remove willReadDst from GrFragmentProcessor.

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"
@@ skipping 54 matching lines @@
             case GrPorterDuffXferProcessor::kNone_PrimaryOutputType:
                 fsBuilder->codeAppendf("%s = vec4(0);", args.fOutputPrimary);
                 break;
             case GrPorterDuffXferProcessor::kColor_PrimaryOutputType:
                 fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
                 break;
             case GrPorterDuffXferProcessor::kCoverage_PrimaryOutputType:
                 fsBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputCoverage);
                 break;
             case GrPorterDuffXferProcessor::kModulate_PrimaryOutputType:
-            case GrPorterDuffXferProcessor::kCombineWithDst_PrimaryOutputType:
                 fsBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputColor,
                                        args.fInputCoverage);
-                if (GrPorterDuffXferProcessor::kCombineWithDst_PrimaryOutputType ==
-                    xp.primaryOutputType()){
-                    fsBuilder->codeAppendf("%s += (vec4(1.0) - %s) * %s;", args.fOutputPrimary,
-                                           args.fInputCoverage, fsBuilder->dstColor());
-                }
                 break;
             default:
                 SkFAIL("Unexpected Primary Output");
         }
     }
 
     void setData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
 
     static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
                        GrProcessorKeyBuilder* b) {
@@ skipping 44 matching lines @@
         // 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,
                                                   doesStencilWrite);
     }
-    this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite(),
-                          colorPOI.readsDst() || coveragePOI.readsDst());
+    this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite());
     return optFlags;
 }
 
 void GrPorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
                                                 const GrDrawTargetCaps& caps,
-                                                bool hasSolidCoverage, bool readsDst) {
+                                                bool hasSolidCoverage) {
     if (optFlags & kIgnoreColor_OptFlag) {
         if (optFlags & kIgnoreCoverage_OptFlag) {
             fPrimaryOutputType = kNone_PrimaryOutputType;
             return;
         } else {
             fPrimaryOutputType = kCoverage_PrimaryOutputType;
             return;
         }
     } else if (optFlags & kIgnoreCoverage_OptFlag) {
         fPrimaryOutputType = kColor_PrimaryOutputType;
@@ skipping 12 matching lines @@
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSA_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
                 fSecondaryOutputType = kCoverageISA_SecondaryOutputType;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSC_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
                 fSecondaryOutputType = kCoverageISC_SecondaryOutputType;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             }
-        } else if (readsDst &&
-                   kOne_GrBlendCoeff == fSrcBlend &&
-                   kZero_GrBlendCoeff == fDstBlend) {
-            fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
         }
     }
 }
 
 GrXferProcessor::OptFlags
 GrPorterDuffXferProcessor::internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
                                                     bool doesStencilWrite) {
     bool srcAIsOne;
     bool hasCoverage;
@@ skipping 211 matching lines @@
     if (dstCoeffIsZero) {
         if (kZero_GrBlendCoeff == fSrcCoeff) {
             return true;
         } else if (srcAIsOne) {
             return  true;
         }
     } else if (dstCoeffIsOne) {
         return true;
     }
 
-    // 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 ((colorPOI.readsDst() || coveragePOI.readsDst()) &&
-        kOne_GrBlendCoeff == fSrcCoeff && kZero_GrBlendCoeff == fDstCoeff) {
-        return true;
-    }
-
     return false;
 }
 
 bool GrPorterDuffXPFactory::canTweakAlphaForCoverage() const {
     return can_tweak_alpha_for_coverage(fDstCoeff);
 }
 
 void GrPorterDuffXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                GrXPFactory::InvariantOutput* output) const {
@@ skipping 53 matching lines @@
 
             // TODO: update this once GrPaint actually has a const color.
         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 (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);
 }