Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/glsl/GrGLSLCaps.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 GrGLSLCaps_DEFINED
 #define GrGLSLCaps_DEFINED
@@ skipping 56 matching lines @@
         return fGLSLGeneration > k110_GrGLSLGeneration;
     }
 
     bool usesPrecisionModifiers() const { return fUsesPrecisionModifiers; }
 
     // Returns whether we can use the glsl funciton any() in our shader code.
     bool canUseAnyFunctionInShader() const { return fCanUseAnyFunctionInShader; }
 
     bool forceHighPrecisionNDSTransform() const { return fForceHighPrecisionNDSTransform; }
 
+    bool textureSwizzleSupport() const { return fTextureSwizzleSupport; }

[bsalomon, 2015/10/30 17:10:53]

These two seem like features of the API and not of the shading language...
They're used only on the API side.

The way we handle this is tied to our not so great mapping between GL formats
and GrPixelConfigs. I wonder if there is any way to handle this that would add
some flexibility. E.g., could the GLSL caps get populated with a table that
holds four swizzle values for each GrPixelConfig? The GL impl could base the
table on whether R8 is supported and whether texture swizzling is supported.

We currently use texture swizzling to implement R/B swaps for read-/write-pixels
codepaths. I'd be happy to drop that if it could improve this somehow. I doubt
having the extra shader is worth much complexity.

+
+    bool textureRedSupport() const { return fTextureRedSupport; }
+
+    // Returns the string of an extension that must be enabled in the shader to support
+    // derivatives. If nullptr is returned then no extension needs to be enabled. Before calling
+    // this function, the caller should check that shaderDerivativeSupport exists.
+    const char* shaderDerivativeExtensionString() const {
+        SkASSERT(this->shaderDerivativeSupport());
+        return fShaderDerivativeExtensionString;
+    }
+
     GrGLSLGeneration generation() const { return fGLSLGeneration; }
 
     /**
     * Returns a string containing the caps info.
     */
     SkString dump() const override;
 
 private:
     GrGLSLGeneration fGLSLGeneration;
     
     bool fDropsTileOnZeroDivide : 1;
     bool fFBFetchSupport : 1;
     bool fFBFetchNeedsCustomOutput : 1;
     bool fBindlessTextureSupport : 1;
     bool fUsesPrecisionModifiers : 1;
     bool fCanUseAnyFunctionInShader : 1;
     bool fForceHighPrecisionNDSTransform : 1;
+    bool fTextureSwizzleSupport : 1;
+    bool fTextureRedSupport : 1;
 
     const char* fVersionDeclString;
 
+    const char* fShaderDerivativeExtensionString;
+
     const char* fFBFetchColorName;
     const char* fFBFetchExtensionString;
 
     AdvBlendEqInteraction fAdvBlendEqInteraction;
 
     friend class GrGLCaps;  // For initialization.
 
     typedef GrShaderCaps INHERITED;
 };
 
 
 #endif