Replace fWillReadFragmentPosition with a bitfield

src/gpu/glsl/GrGLSLProgramBuilder.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "glsl/GrGLSLProgramBuilder.h"
 
 #include "GrPipeline.h"
@@ skipping 81 matching lines @@
                                            proc,
                                            outputColor->c_str(),
                                            outputCoverage->c_str(),
                                            samplers,
                                            fCoordTransforms,
                                            &fOutCoords);
     fGeometryProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
-    verify(proc);
+    SkDEBUGCODE(verify(proc);)
 
     fFS.codeAppend("}");
 }
 
 void GrGLSLProgramBuilder::emitAndInstallFragProcs(int procOffset,
                                                    int numProcs,
                                                    GrGLSLExpr4* inOut) {
     for (int i = procOffset; i < numProcs; ++i) {
         GrGLSLExpr4 output;
         const GrFragmentProcessor& fp = this->pipeline().getFragmentProcessor(i);
@@ skipping 27 matching lines @@
                                            this->glslCaps(),
                                            fp,
                                            output->c_str(),
                                            input.isOnes() ? nullptr : input.c_str(),
                                            fOutCoords[index],
                                            samplers);
     fragProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
-    verify(fp);
+    SkDEBUGCODE(verify(fp);)
     fFragmentProcessors.push_back(fragProc);
 
     fFS.codeAppend("}");
 }
 
 void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                                   const GrGLSLExpr4& colorIn,
                                                   const GrGLSLExpr4& coverageIn,
                                                   bool ignoresCoverage,
                                                   GrPixelLocalStorageState plsState) {
@@ skipping 26 matching lines @@
                                        xp, colorIn.c_str(),
                                        ignoresCoverage ? nullptr : coverageIn.c_str(),
                                        fFS.getPrimaryColorOutputName(),
                                        fFS.getSecondaryColorOutputName(),
                                        samplers,
                                        usePLSDstRead);
     fXferProcessor->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
-    verify(xp);
+    SkDEBUGCODE(verify(xp);)
     fFS.codeAppend("}");
 }
 
 void GrGLSLProgramBuilder::emitFSOutputSwizzle(bool hasSecondaryOutput) {
     // Swizzle the fragment shader outputs if necessary.
     GrSwizzle swizzle;
     swizzle.setFromKey(this->desc().header().fOutputSwizzle);
     if (swizzle != GrSwizzle::RGBA()) {
         fFS.codeAppendf("%s = %s.%s;", fFS.getPrimaryColorOutputName(),
                         fFS.getPrimaryColorOutputName(),
                         swizzle.c_str());
         if (hasSecondaryOutput) {
             fFS.codeAppendf("%s = %s.%s;", fFS.getSecondaryColorOutputName(),
                             fFS.getSecondaryColorOutputName(),
                             swizzle.c_str());
         }
     }
 }
 
+#ifdef SK_DEBUG
 void GrGLSLProgramBuilder::verify(const GrPrimitiveProcessor& gp) {
-    SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
+    SkASSERT(fFS.usedProcessorFeatures() == gp.requiredFeatures());
 }
 
 void GrGLSLProgramBuilder::verify(const GrXferProcessor& xp) {
+    SkASSERT(fFS.usedProcessorFeatures() == xp.requiredFeatures());
     SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
 }
 
 void GrGLSLProgramBuilder::verify(const GrFragmentProcessor& fp) {
-    SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
+    SkASSERT(fFS.usedProcessorFeatures() == fp.requiredFeatures());
 }
+#endif
 
 void GrGLSLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
     if (mangle) {
         if (out->endsWith('_')) {
             // Names containing "__" are reserved.
@@ skipping 47 matching lines @@
         delete fFragmentProcessors[i];
     }
 }
 
 void GrGLSLProgramBuilder::finalizeShaders() {
     this->varyingHandler()->finalize();
     fVS.finalize(kVertex_GrShaderFlag);
     fFS.finalize(kFragment_GrShaderFlag);
 
 }