Fix LCD coverage regression in GrPorterDuffXPFactory

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 726 matching lines @@
     if (SkXfermode::kSrcOver_Mode == fXfermode &&
         kRGBA_GrColorComponentFlags == knownColorFlags) {
         return true;
     }
     return false;
 }
 
 void GrPorterDuffXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                GrXPFactory::InvariantOutput* output) const {
-    const BlendFormula& blendFormula = get_blend_formula(fXfermode, colorPOI, coveragePOI);
+    output->fWillBlendWithDst = true;
+    output->fBlendedColorFlags = kNone_GrColorComponentFlags;
 
-    if (blendFormula.usesDstColor()) {
-        output->fWillBlendWithDst = true;
-        output->fBlendedColorFlags = kNone_GrColorComponentFlags;
+    // The LCD coverage XP doesn't use the blend table, and has no invariant output.
+    if (coveragePOI.isFourChannelOutput()) {
         return;
     }
 
+    const BlendFormula& blendFormula = get_blend_formula(fXfermode, colorPOI, coveragePOI);
+    if (blendFormula.usesDstColor()) {
+        return;
+    }
+
     SkASSERT(coveragePOI.isSolidWhite());
     SkASSERT(kAdd_GrBlendEquation == blendFormula.fBlendEquation);
 
     output->fWillBlendWithDst = false;
 
     switch (blendFormula.fSrcCoeff) {
         case kZero_GrBlendCoeff:
             output->fBlendedColor = 0;
             output->fBlendedColorFlags = kRGBA_GrColorComponentFlags;
             return;
 
         case kOne_GrBlendCoeff:
             output->fBlendedColor = colorPOI.color();
             output->fBlendedColorFlags = colorPOI.validFlags();
             return;
 
-        // TODO: update if we ever use const color.
-        default:
-            output->fBlendedColorFlags = kNone_GrColorComponentFlags;
-            return;
+        default: return;
     }
 }
 
 bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI) const {
+    // The LCD coverage XP doesn't use the blend table, and never requires a dst read.
+    if (coveragePOI.isFourChannelOutput()) {
+        return false;
+    }
+
     // Some formulas use dual source blending, so we fall back if it is required but not supported.
     return !caps.shaderCaps()->dualSourceBlendingSupport() &&
            get_blend_formula(fXfermode, colorPOI, coveragePOI).hasSecondaryOutput();
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
                                                const GrCaps&,
                                                GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::Mode(random->nextULessThan(SkXfermode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Create(mode);
 }
 
 void GrPorterDuffXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp,
                                                  int* outPrimary,
                                                  int* outSecondary) {
     if (!!strcmp(xp->name(), "Porter Duff")) {
         *outPrimary = *outSecondary = -1;
         return;
     }
     BlendFormula blendFormula = static_cast<const PorterDuffXferProcessor*>(xp)->getBlendFormula();
     *outPrimary = blendFormula.fPrimaryOutputType;
     *outSecondary = blendFormula.fSecondaryOutputType;
 }