Key shader on whether frag pos read is relative to top-left or bottom-left

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 175 matching lines @@
                       const char* body,
                       SkString* outName);
 
     /** Generates a EffectKey for the shader code based on the texture access parameters and the
         capabilities of the GL context.  This is useful for keying the shader programs that may
         have multiple representations, based on the type/format of textures used. */
     static GrBackendEffectFactory::EffectKey KeyForTextureAccess(const GrTextureAccess&,
                                                                  const GrGLCaps&);
 
     typedef uint8_t DstReadKey;
+    typedef uint8_t FragPosKey;
 
     /**  Returns a key for adding code to read the copy-of-dst color in service of effects that
          require reading the dst. It must not return 0 because 0 indicates that there is no dst
-         copy read at all. */
+         copy read at all (in which case this function should not be called). */
     static DstReadKey KeyForDstRead(const GrTexture* dstCopy, const GrGLCaps&);
 
+    /** Returns a key for reading the fragment location. This should only be called if there is an
+        effect that will requires the fragment position. If the fragment position is not required,
+        the key is 0. */
+    static FragPosKey KeyForFragmentPosition(const GrRenderTarget* dst, const GrGLCaps&);
+
     /** If texture swizzling is available using tex parameters then it is preferred over mangling
         the generated shader code. This potentially allows greater reuse of cached shaders. */
     static const GrGLenum* GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps);
 
     /** Add a uniform variable to the current program, that has visibility in one or more shaders.
         visibility is a bitfield of ShaderType values indicating from which shaders the uniform
         should be accessible. At least one bit must be set. Geometry shader uniforms are not
         supported at this time. The actual uniform name will be mangled. If outName is not NULL then
         it will refer to the final uniform name after return. Use the addUniformArray variant to add
         an array of uniforms.
@@ skipping 205 matching lines @@
     void nameVariable(SkString* out, char prefix, const char* name);
 
     // Interpretation of DstReadKey when generating code
     enum {
         kNoDstRead_DstReadKey         = 0,
         kYesDstRead_DstReadKeyBit     = 0x1, // Set if we do a dst-copy-read.
         kUseAlphaConfig_DstReadKeyBit = 0x2, // Set if dst-copy config is alpha only.
         kTopLeftOrigin_DstReadKeyBit  = 0x4, // Set if dst-copy origin is top-left.
     };
 
+    enum {
+        kNoFragPosRead_FragPosKey           = 0,  // The fragment positition will not be needed.
+        kTopLeftFragPosRead_FragPosKey      = 0x1,// Read frag pos relative to top-left.
+        kBottomLeftFragPosRead_FragPosKey   = 0x2,// Read frag pos relative to bottom-left.
+    };
+
     const GrGLContextInfo&              fCtxInfo;
     GrGLUniformManager&                 fUniformManager;
     uint32_t                            fFSFeaturesAddedMask;
     SkString                            fFSFunctions;
     SkString                            fFSExtensions;
 
     bool                                fUsesGS;
 
     SkString                            fFSCode;
     SkString                            fVSCode;
     SkString                            fGSCode;
 
     bool                                fSetupFragPosition;
     TextureSampler                      fDstCopySampler;
 
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
     GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
 
+    bool                                fTopLeftFragPosRead;
+
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif