Update XPF invariant info to not account for conflation

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 691 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.
         *overrideColor = GrColorPackRGBA(fAlpha, fAlpha, fAlpha, fAlpha);
         return GrXferProcessor::kOverrideColor_OptFlag;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode)
     : fXfermode(xfermode) {
+    SkASSERT(fXfermode <= SkXfermode::kLastCoeffMode);
     this->initClassID<GrPorterDuffXPFactory>();
 }
 
 GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode xfermode) {
     static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
     static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
     static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
     static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
     static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
     static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
@@ skipping 41 matching lines @@
 
 bool GrPorterDuffXPFactory::supportsRGBCoverage(GrColor /*knownColor*/,
                                                 uint32_t knownColorFlags) const {
     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 {
-    output->fWillBlendWithDst = true;
-    output->fBlendedColorFlags = kNone_GrColorComponentFlags;
-
-    // The blend table doesn't support LCD coverage, but these formulas never have invariant output.
-    if (coveragePOI.isFourChannelOutput()) {
+void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
+                                                     const GrProcOptInfo& /*coveragePOI*/,
+                                                     InvariantBlendedColor* blendedColor) const {
+    // Find the blended color info based on the formula that does not have coverage.
+    BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode];
+    if (colorFormula.usesDstColor()) {
+        blendedColor->fWillBlendWithDst = true;
+        blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
         return;
     }
 
-    const BlendFormula& blendFormula = get_blend_formula(fXfermode, colorPOI, coveragePOI);
-    if (blendFormula.usesDstColor()) {
-        return;
-    }
+    blendedColor->fWillBlendWithDst = false;
 
-    SkASSERT(coveragePOI.isSolidWhite());
-    SkASSERT(kAdd_GrBlendEquation == blendFormula.fBlendEquation);
+    SkASSERT(kAdd_GrBlendEquation == colorFormula.fBlendEquation);
 
-    output->fWillBlendWithDst = false;
-
-    switch (blendFormula.fSrcCoeff) {
+    switch (colorFormula.fSrcCoeff) {
         case kZero_GrBlendCoeff:
-            output->fBlendedColor = 0;
-            output->fBlendedColorFlags = kRGBA_GrColorComponentFlags;
+            blendedColor->fKnownColor = 0;
+            blendedColor->fKnownColorFlags = kRGBA_GrColorComponentFlags;
             return;
 
         case kOne_GrBlendCoeff:
-            output->fBlendedColor = colorPOI.color();
-            output->fBlendedColorFlags = colorPOI.validFlags();
+            blendedColor->fKnownColor = colorPOI.color();
+            blendedColor->fKnownColorFlags = colorPOI.validFlags();
             return;
 
-        default: return;
+        default:
+            blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
+            return;
     }
 }
 
 bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI) const {
     if (coveragePOI.isFourChannelOutput()) {
         return false; // The LCD XP never does a dst read.
     }
 
@@ skipping 18 matching lines @@
                                                  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;
 }