Force input coverage to be only a byte in gpu shaders.

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 371 matching lines @@
             kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff);
 }
 
 bool GrDrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
 
     GrProcessor::InvariantOutput inout;
-    inout.fIsSingleComponent = false;
+    inout.fIsSingleComponent = true;
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
         inout.fValidFlags = 0;
     } else {
         inout.fColor = this->getCoverageColor();
         inout.fValidFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
     if (this->hasGeometryProcessor()) {
@@ skipping 328 matching lines @@
     for (int s = 0; s < this->numColorStages(); ++s) {
         const GrProcessor* processor = this->getColorStage(s).getProcessor();
         processor->computeInvariantOutput(&inoutColor);
     }
 
     // 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.
         GrProcessor::InvariantOutput inoutCoverage;
-        inoutCoverage.fIsSingleComponent = false;
+        inoutCoverage.fIsSingleComponent = true;
         if (this->hasCoverageVertexAttribute()) {
             inoutCoverage.fValidFlags = 0;
             inoutCoverage.fColor = 0; // suppresses any warnings.
         } else {
             inoutCoverage.fValidFlags = kRGBA_GrColorComponentFlags;
             inoutCoverage.fColor = this->getCoverageColor();
         }
 
         if (this->hasGeometryProcessor()) {
             fGeometryProcessor->computeInvariantOutput(&inoutCoverage);
         }
 
         // Run through the coverage stages
         for (int s = 0; s < this->numCoverageStages(); ++s) {
             const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
             processor->computeInvariantOutput(&inoutCoverage);
         }
 
         // 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 (inoutColor.isOpaque() && inoutCoverage.isOpaque());
     }
 
     return inoutColor.isOpaque();
 }