Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/gl/builders/GrGLFragmentShaderBuilder.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 GrGLFragmentShaderBuilder_DEFINED
 #define GrGLFragmentShaderBuilder_DEFINED
 
 #include "GrGLShaderBuilder.h"
 
+#include "gl/GrGLTypes.h"
 #include "glsl/GrGLSLProcessorTypes.h"
 
+class GrRenderTarget;
 class GrGLVarying;
 
 /*
  * This base class encapsulates the functionality which the GP uses to build fragment shaders
  */
 class GrGLFragmentBuilder : public GrGLShaderBuilder {
 public:
     GrGLFragmentBuilder(GrGLProgramBuilder* program)
         : INHERITED(program) {
         fSubstageIndices.push_back(0);
@@ skipping 79 matching lines @@
         if these equations are supported. */
     virtual void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) = 0;
 
 private:
     typedef GrGLFragmentBuilder INHERITED;
 };
 
 // TODO rename to Fragment Builder
 class GrGLFragmentShaderBuilder : public GrGLXPFragmentBuilder {
 public:
-    typedef uint8_t DstReadKey;
     typedef uint8_t FragPosKey;
 
-    /** Returns a key for adding code to read the dst texture color in service of effects that
-        require reading the dst. It must not return 0 because 0 indicates that there is no dst
-        texture at all (in which case this function should not be called). */
-    static DstReadKey KeyForDstRead(const GrTexture* dsttexture, 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&);
+    static FragPosKey KeyForFragmentPosition(const GrRenderTarget* dst);
 
     GrGLFragmentShaderBuilder(GrGLProgramBuilder* program, uint8_t fragPosKey);
 
     // true public interface, defined explicitly in the abstract interfaces above
     bool enableFeature(GLSLFeature) override;
     virtual SkString ensureFSCoords2D(const GrGLSLTransformedCoordsArray& coords,
                                       int index) override;
     const char* fragmentPosition() override;
     const char* dstColor() override;
 
     void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override;
 
 private:
     // Private public interface, used by GrGLProgramBuilder to build a fragment shader
     void enableCustomOutput();
     void enableSecondaryOutput();
     const char* getPrimaryColorOutputName() const;
     const char* getSecondaryColorOutputName() const;
-    bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds);
     void bindFragmentShaderLocations(GrGLuint programID);
 
     // As GLProcessors emit code, there are some conditions we need to verify.  We use the below
     // state to track this.  The reset call is called per processor emitted.
     bool hasReadDstColor() const { return fHasReadDstColor; }
     bool hasReadFragmentPosition() const { return fHasReadFragmentPosition; }
     void reset() {
         fHasReadDstColor = false;
         fHasReadFragmentPosition = false;
     }
 
     /*
      * An internal call for GrGLProgramBuilder to use to add varyings to the vertex shader
      */
     void addVarying(GrGLVarying*, GrSLPrecision);
 
+    void onFinalize() override;
+
     /**
      * Features that should only be enabled by GrGLFragmentShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kBlendEquationAdvanced_GLSLPrivateFeature,
         kBlendFuncExtended_GLSLPrivateFeature,
         kLastGLSLPrivateFeature = kBlendFuncExtended_GLSLPrivateFeature
     };
 
-    // 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.
-    };
-
     // Interpretation of FragPosKey when generating code
     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.
     };
 
     static const char* kDstTextureColorName;
 
     bool fHasCustomColorOutput;
     bool fHasSecondaryOutput;
     bool fSetupFragPosition;
     bool fTopLeftFragPosRead;
     int  fCustomColorOutputIndex;
 
     // some state to verify shaders and effects are consistent, this is reset between effects by
     // the program creator
     bool fHasReadDstColor;
     bool fHasReadFragmentPosition;
 
     friend class GrGLProgramBuilder;
 
     typedef GrGLXPFragmentBuilder INHERITED;
 };
 
 #endif