Add isSingleComponent bool to getConstantColorComponent

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 
 #include "GrOptDrawState.h"
@@ skipping 405 matching lines @@
 }
 
 bool GrDrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
 
     GrColor coverage;
     uint32_t validComponentFlags;
+    bool isSingleComponent = false;
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
         validComponentFlags = 0;
     } else {
         coverage = fCoverage;
         validComponentFlags = 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->getConstantColorComponents(&coverage, &validComponentFlags, &isSingleComponent);
     }
     for (int s = 0; s < this->numCoverageStages(); ++s) {
         const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
-        processor->getConstantColorComponents(&coverage, &validComponentFlags);
+        processor->getConstantColorComponents(&coverage, &validComponentFlags, &isSingleComponent);
     }
     return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrDrawState::AutoVertexAttribRestore::AutoVertexAttribRestore(GrDrawState* drawState) {
     SkASSERT(drawState);
     fDrawState = drawState;
     fVAPtr = drawState->fVAPtr;
@@ skipping 298 matching lines @@
         }
     }
 
     return kNone_BlendOpt;
 }
 
 
 bool GrDrawState::srcAlphaWillBeOne() const {
     uint32_t validComponentFlags;
     GrColor color;
+    bool 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;
         } else {
             validComponentFlags = 0;
             color = 0; // not strictly necessary but we get false alarms from tools about uninit.
         }
     } else {
         validComponentFlags = kRGBA_GrColorComponentFlags;
         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->getConstantColorComponents(&color, &validComponentFlags, &isSingleComponent);
     }
 
     // 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;
         if (this->hasCoverageVertexAttribute()) {
             coverageComponentFlags = 0;
             coverage = 0; // suppresses any warnings.
         } else {
             coverageComponentFlags = kRGBA_GrColorComponentFlags;
             coverage = 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->getConstantColorComponents(&coverage, &coverageComponentFlags, &isSingleComponent);

[joshua.litt, 2014/09/29 15:22:08]

Newline

[egdaniel, 2014/09/29 15:50:20]

Done.

         }
 
         // 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 (kA_GrColorComponentFlag & validComponentFlags) && 0xFF == GrColorUnpackA(color);
 }