Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/gl/builders/GrGLShaderBuilder.h

 /*
  * Copyright 2014 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
 
-#include "SkTArray.h"
-#include "gl/GrGLFragmentProcessor.h"
-#include "gl/GrGLProgramDesc.h"
-#include "gl/GrGLProgramDataManager.h"
-#include "gl/GrGLTypes.h"
+#include "GrAllocator.h"
+#include "glsl/GrGLSLShaderVar.h"
+#include "SkTDArray.h"
 
 #include <stdarg.h>
 
-class GrGLCaps;
-class GrGLContextInfo;
 class GrGLProgramBuilder;
 class GrGLSLTextureSampler;
 
 /**
   base class for all shaders builders
 */
 class GrGLShaderBuilder {
 public:
     GrGLShaderBuilder(GrGLProgramBuilder* program);
+    virtual ~GrGLShaderBuilder() {}
 
     void addInput(const GrGLSLShaderVar& input) { fInputs.push_back(input); }
     void addOutput(const GrGLSLShaderVar& output) { fOutputs.push_back(output); }
 
     /*
      * We put texture lookups in the base class because it is TECHNICALLY possible to do texture
      * lookups in any kind of shader.  However, for the time being using these calls on non-fragment
      * shaders will result in a shader compilation error as texture sampler uniforms are only
      * visible to the fragment shader.  It would not be hard to change this behavior, if someone
      * actually wants to do texture lookups in a non-fragment shader
@@ skipping 18 matching lines @@
 
     /** Does the work of appendTextureLookup and modulates the result by modulation. The result is
         always a vec4. modulation and the swizzle specified by GrGLSLTextureSampler must both be
         vec4 or float. If modulation is "" or nullptr it this function acts as though
         appendTextureLookup were called. */
     void appendTextureLookupAndModulate(const char* modulation,
                                         const GrGLSLTextureSampler&,
                                         const char* coordName,
                                         GrSLType coordType = kVec2f_GrSLType);
 
-    /** 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);
-
     /**
     * Called by GrGLProcessors to add code to one of the shaders.
     */
     void codeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
        va_list args;
        va_start(args, format);
        this->code().appendVAList(format, args);
        va_end(args);
     }
 
@@ skipping 13 matching lines @@
 
     /** Emits a helper function outside of main() in the fragment shader. */
     void emitFunction(GrSLType returnType,
                       const char* name,
                       int argCnt,
                       const GrGLSLShaderVar* args,
                       const char* body,
                       SkString* outName);
 
     /*
+     * Combines the various parts of the shader to create a single finalized shader string.
+     */
+    void finalize(uint32_t visibility);
+
+    /*
      * Get parent builder for adding uniforms
      */
     GrGLProgramBuilder* getProgramBuilder() { return fProgramBuilder; }
 
     /**
      * Helper for begining and ending a block in the shader code.
      */
     class ShaderBlock {
     public:
         ShaderBlock(GrGLShaderBuilder* builder) : fBuilder(builder) {
@@ skipping 51 matching lines @@
     SkString& versionDecl() { return fShaderStrings[kVersionDecl]; }
     SkString& extensions() { return fShaderStrings[kExtensions]; }
     SkString& precisionQualifier() { return fShaderStrings[kPrecisionQualifier]; }
     SkString& layoutQualifiers() { return fShaderStrings[kLayoutQualifiers]; }
     SkString& uniforms() { return fShaderStrings[kUniforms]; }
     SkString& inputs() { return fShaderStrings[kInputs]; }
     SkString& outputs() { return fShaderStrings[kOutputs]; }
     SkString& functions() { return fShaderStrings[kFunctions]; }
     SkString& main() { return fShaderStrings[kMain]; }
     SkString& code() { return fShaderStrings[fCodeIndex]; }
-    bool finalize(GrGLuint programId, GrGLenum type, SkTDArray<GrGLuint>* shaderIds);
+
+    virtual void onFinalize() = 0;
 
     enum {
         kVersionDecl,
         kExtensions,
         kPrecisionQualifier,
         kLayoutQualifiers,
         kUniforms,
         kInputs,
         kOutputs,
         kFunctions,
@@ skipping 13 matching lines @@
     VarArray fOutputs;
     uint32_t fFeaturesAddedMask;
     SkSTArray<1, SkString> fLayoutParams[kLastInterfaceQualifier + 1];
     int fCodeIndex;
     bool fFinalized;
 
     friend class GrGLProgramBuilder;
     friend class GrGLPathProgramBuilder; // to access fInputs.
 };
 #endif