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

src/gpu/gl/builders/GrGLProgramBuilder.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 "GrGLProgramBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
@@ skipping 30 matching lines @@
     GrGLProgramBuilder* pb = builder.get();
     const GrGLProgramDescBuilder::GLKeyHeader& header = GrGLProgramDescBuilder::GetHeader(pb->desc());
 
     // emit code to read the dst copy texture, if necessary
     if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey
             && !gpu->glCaps().fbFetchSupport()) {
         pb->fFS.emitCodeToReadDstTexture();
     }
 
     // get the initial color and coverage to feed into the first effect in each effect chain
-    GrGLSLExpr4 inputColor, inputCoverage;
+    GrGLSLExpr4 inputColor;
+    GrGLSLExpr1 inputCoverage;
     pb->setupUniformColorAndCoverageIfNeeded(&inputColor,  &inputCoverage);
 
     // if we have a vertex shader(we don't only if we are using NVPR or NVPR ES), then we may have
     // to setup a few more things like builtin vertex attributes
     bool hasVertexShader = !(header.fUseNvpr &&
                              gpu->glPathRendering()->texturingMode() ==
                              GrGLPathRendering::FixedFunction_TexturingMode);
     if (hasVertexShader) {
         pb->fVS.setupLocalCoords();
         pb->fVS.transformGLToSkiaCoords();
         if (header.fEmitsPointSize) {
             pb->fVS.codeAppend("gl_PointSize = 1.0;");
         }
         if (GrProgramDesc::kAttribute_ColorInput == header.fColorInput) {
             pb->fVS.setupBuiltinVertexAttribute("Color", &inputColor);
         }
         if (GrProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
             pb->fVS.setupBuiltinVertexAttribute("Coverage", &inputCoverage);
         }
     }
 
-    pb->emitAndInstallProcs(optState, &inputColor, &inputCoverage);
+    // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
+    // remove this cast to a vec4.
+    GrGLSLExpr4 inputCoverageVec4 = GrGLSLExpr4::VectorCast(inputCoverage);
+
+    pb->emitAndInstallProcs(optState, &inputColor, &inputCoverageVec4);
 
     if (hasVertexShader) {
         pb->fVS.transformSkiaToGLCoords();
     }
 
     // write the secondary color output if necessary
     if (GrProgramDesc::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
-        pb->fFS.enableSecondaryOutput(inputColor, inputCoverage);
+        pb->fFS.enableSecondaryOutput(inputColor, inputCoverageVec4);
     }
 
-    pb->fFS.combineColorAndCoverage(inputColor, inputCoverage);
+    pb->fFS.combineColorAndCoverage(inputColor, inputCoverageVec4);
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder*
 GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
                                          GrGpu::DrawType drawType,
                                          bool hasGeometryProcessor,
                                          GrGpuGL* gpu) {
     const GrProgramDesc& desc = optState.programDesc();
@@ skipping 97 matching lines @@
             out->append(";\n");
         }
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
 void GrGLProgramBuilder::setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor,
-                                                              GrGLSLExpr4* inputCoverage) {
+                                                              GrGLSLExpr1* inputCoverage) {
     const GrProgramDesc::KeyHeader& header = this->header();
     if (GrProgramDesc::kUniform_ColorInput == header.fColorInput) {
         const char* name;
         fUniformHandles.fColorUni =
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                              kVec4f_GrSLType,
                              "Color",
                              &name);
         *inputColor = GrGLSLExpr4(name);
     } else if (GrProgramDesc::kAllOnes_ColorInput == header.fColorInput) {
         *inputColor = GrGLSLExpr4(1);
     }
     if (GrProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
         const char* name;
         fUniformHandles.fCoverageUni =
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                             kVec4f_GrSLType,
+                             kFloat_GrSLType,
                              "Coverage",
                              &name);
-        *inputCoverage = GrGLSLExpr4(name);
+        *inputCoverage = GrGLSLExpr1(name);
     } else if (GrProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
-        *inputCoverage = GrGLSLExpr4(1);
+        *inputCoverage = GrGLSLExpr1(1);
     }
 }
 
 void GrGLProgramBuilder::emitAndInstallProcs(const GrOptDrawState& optState,
                                              GrGLSLExpr4* inputColor,
                                              GrGLSLExpr4* inputCoverage) {
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = optState.numFragmentStages();
     this->emitAndInstallFragProcs(0, optState.numColorStages(), inputColor);
     if (optState.hasGeometryProcessor()) {
@@ skipping 276 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }