Make all blending up to GrOptDrawState be handled by the xp/xp factory.

In this cl the blending information is extracted for the xp and stored in the ODS
which is then used as it currently is. In the follow up cl, an XP backend will be added
and at that point all blending work will take place inside XP's.

BUG=skia:

Review URL: https://codereview.chromium.org/759713002

1 files changed, 3 insertions, 57 deletions

diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp
index 443e1c0abf..5ed573a88b 100644
--- a/src/gpu/GrPaint.cpp
+++ b/src/gpu/GrPaint.cpp
@@ -8,7 +8,6 @@
 
 #include "GrPaint.h"
 
-#include "GrBlend.h"
 #include "GrProcOptInfo.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrSimpleTextureEffect.h"
@@ -52,73 +51,20 @@ bool GrPaint::isOpaqueAndConstantColor(GrColor* color) const {
 void GrPaint::resetStages() {
     fColorStages.reset();
     fCoverageStages.reset();
-    fXPFactory.reset(GrPorterDuffXPFactory::Create(SkXfermode::kSrcOver_Mode));
+    fXPFactory.reset(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode));
 }
 
 bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor,
                                      uint32_t* solidColorKnownComponents) const {
 
-    // TODO: Share this implementation with GrDrawState
-    
     GrProcOptInfo coverageProcInfo;
     coverageProcInfo.calcWithInitialValues(fCoverageStages.begin(), this->numCoverageStages(),
                                            0xFFFFFFFF, kRGBA_GrColorComponentFlags, true);
-
-    if (!coverageProcInfo.isSolidWhite()) {
-        return false;
-    }
-
     GrProcOptInfo colorProcInfo;
     colorProcInfo.calcWithInitialValues(fColorStages.begin(), this->numColorStages(), fColor,
                                         kRGBA_GrColorComponentFlags, false);
 
-    SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents));
-
-    GrBlendCoeff srcCoeff = fSrcBlendCoeff;
-    GrBlendCoeff dstCoeff = fDstBlendCoeff;
-    GrSimplifyBlend(&srcCoeff, &dstCoeff, colorProcInfo.color(), colorProcInfo.validFlags(),
-                    0, 0, 0);
-
-    bool opaque = kZero_GrBlendCoeff == dstCoeff && !GrBlendCoeffRefsDst(srcCoeff);
-    if (solidColor) {
-        if (opaque) {
-            switch (srcCoeff) {
-                case kZero_GrBlendCoeff:
-                    *solidColor = 0;
-                    *solidColorKnownComponents = kRGBA_GrColorComponentFlags;
-                    break;
-
-                case kOne_GrBlendCoeff:
-                    *solidColor = colorProcInfo.color();
-                    *solidColorKnownComponents = colorProcInfo.validFlags();
-                    break;
-
-                // The src coeff should never refer to the src and if it refers to dst then opaque
-                // should have been false.
-                case kSC_GrBlendCoeff:
-                case kISC_GrBlendCoeff:
-                case kDC_GrBlendCoeff:
-                case kIDC_GrBlendCoeff:
-                case kSA_GrBlendCoeff:
-                case kISA_GrBlendCoeff:
-                case kDA_GrBlendCoeff:
-                case kIDA_GrBlendCoeff:
-                default:
-                    SkFAIL("srcCoeff should not refer to src or dst.");
-                    break;
-
-                // TODO: update this once GrPaint actually has a const color.
-                case kConstC_GrBlendCoeff:
-                case kIConstC_GrBlendCoeff:
-                case kConstA_GrBlendCoeff:
-                case kIConstA_GrBlendCoeff:
-                    *solidColorKnownComponents = 0;
-                    break;
-            }
-        } else {
-            solidColorKnownComponents = 0;
-        }
-    }
-    return opaque;
+    return fXPFactory->getOpaqueAndKnownColor(colorProcInfo, coverageProcInfo, solidColor,
+                                              solidColorKnownComponents);
 }