Add isSingleComponent bool to getConstantColorComponent

src/gpu/GrDrawState.cpp

Index: src/gpu/GrDrawState.cpp
diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp
index 872d20a1ab48cb0c9ae6b0e93fb066a4a3e9fa7c..d79ad17d13523cc625b4e67632d94a27534f0393 100644
--- a/src/gpu/GrDrawState.cpp
+++ b/src/gpu/GrDrawState.cpp
@@ -421,26 +421,26 @@ bool GrDrawState::hasSolidCoverage() const {
         return true;
     }
 
-    GrColor coverage;
-    uint32_t validComponentFlags;
+    GrProcessor::InvarientOutput invarientOutput;
+    invarientOutput.isSingleComponent = false;
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
-        validComponentFlags = 0;
+        invarientOutput.validFlags = 0;
     } else {
-        coverage = fCoverage;
-        validComponentFlags = kRGBA_GrColorComponentFlags;
+        invarientOutput.color = fCoverage;
+        invarientOutput.validFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
     if (this->hasGeometryProcessor()) {
         const GrGeometryProcessor* gp = fGeometryProcessor->getGeometryProcessor();
-        gp->getConstantColorComponents(&coverage, &validComponentFlags);
+        gp->computeInvarientOutput(&invarientOutput);
     }
     for (int s = 0; s < this->numCoverageStages(); ++s) {
         const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
-        processor->getConstantColorComponents(&coverage, &validComponentFlags);
+        processor->computeInvarientOutput(&invarientOutput);
     }
-    return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
+    return invarientOutput.hasOpaqueColor();
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -755,55 +755,54 @@ GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
 
 
 bool GrDrawState::srcAlphaWillBeOne() const {
-    uint32_t validComponentFlags;
-    GrColor color;
+    GrProcessor::InvarientOutput invarientOutputColor;
+    invarientOutputColor.isSingleComponent = false;
     // Check if per-vertex or constant color may have partial alpha
     if (this->hasColorVertexAttribute()) {
         if (fHints & kVertexColorsAreOpaque_Hint) {
-            validComponentFlags = kA_GrColorComponentFlag;
-            color = 0xFF << GrColor_SHIFT_A;
+            invarientOutputColor.validFlags = kA_GrColorComponentFlag;
+            invarientOutputColor.color = 0xFF << GrColor_SHIFT_A;
         } else {
-            validComponentFlags = 0;
-            color = 0; // not strictly necessary but we get false alarms from tools about uninit.
+            invarientOutputColor.validFlags = 0;
+            // not strictly necessary but we get false alarms from tools about uninit.
+            invarientOutputColor.color = 0;
         }
     } else {
-        validComponentFlags = kRGBA_GrColorComponentFlags;
-        color = this->getColor();
+        invarientOutputColor.validFlags = kRGBA_GrColorComponentFlags;
+        invarientOutputColor.color = this->getColor();
     }
 
     // Run through the color stages
     for (int s = 0; s < this->numColorStages(); ++s) {
         const GrProcessor* processor = this->getColorStage(s).getProcessor();
-        processor->getConstantColorComponents(&color, &validComponentFlags);
+        processor->computeInvarientOutput(&invarientOutputColor);
     }
 
     // Check whether coverage is treated as color. If so we run through the coverage computation.
     if (this->isCoverageDrawing()) {
         // The shader generated for coverage drawing runs the full coverage computation and then
         // makes the shader output be the multiplication of color and coverage. We mirror that here.
-        GrColor coverage;
-        uint32_t coverageComponentFlags;
+        GrProcessor::InvarientOutput invarientOutputCoverage;
+        invarientOutputCoverage.isSingleComponent = false;
         if (this->hasCoverageVertexAttribute()) {
-            coverageComponentFlags = 0;
-            coverage = 0; // suppresses any warnings.
+            invarientOutputCoverage.validFlags = 0;
+            invarientOutputCoverage.color = 0; // suppresses any warnings.
         } else {
-            coverageComponentFlags = kRGBA_GrColorComponentFlags;
-            coverage = this->getCoverageColor();
+            invarientOutputCoverage.validFlags = kRGBA_GrColorComponentFlags;
+            invarientOutputCoverage.color = this->getCoverageColor();
         }
 
         // Run through the coverage stages
         for (int s = 0; s < this->numCoverageStages(); ++s) {
             const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
-            processor->getConstantColorComponents(&coverage, &coverageComponentFlags);
+            processor->computeInvarientOutput(&invarientOutputCoverage);
         }
 
         // Since the shader will multiply coverage and color, the only way the final A==1 is if
         // coverage and color both have A==1.
-        return (kA_GrColorComponentFlag & validComponentFlags & coverageComponentFlags) &&
-                0xFF == GrColorUnpackA(color) && 0xFF == GrColorUnpackA(coverage);
-
+        return (invarientOutputColor.hasOpaqueAlpha() && invarientOutputCoverage.hasOpaqueAlpha());
     }
 
-    return (kA_GrColorComponentFlag & validComponentFlags) && 0xFF == GrColorUnpackA(color);
+    return invarientOutputColor.hasOpaqueAlpha();
 }