Move all ShaderBuilder files to GLSL

src/gpu/glsl/GrGLSLFragmentShaderBuilder.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
+#ifndef GrGLSLFragmentShaderBuilder_DEFINED
+#define GrGLSLFragmentShaderBuilder_DEFINED
 
-#include "GrGLShaderBuilder.h"
+#include "GrGLSLShaderBuilder.h"
 
 #include "glsl/GrGLSLProcessorTypes.h"
 
 class GrRenderTarget;
 class GrGLSLVarying;
 
 /*
  * This base class encapsulates the functionality which the GP uses to build fragment shaders
  */
-class GrGLFragmentBuilder : public GrGLShaderBuilder {
+class GrGLSLFragmentBuilder : public GrGLSLShaderBuilder {
 public:
-    GrGLFragmentBuilder(GrGLSLProgramBuilder* program)
+    GrGLSLFragmentBuilder(GrGLSLProgramBuilder* program)
         : INHERITED(program)
         , fHasCustomColorOutput(false)
         , fHasSecondaryOutput(false) {
         fSubstageIndices.push_back(0);
     }
-    virtual ~GrGLFragmentBuilder() {}
+    virtual ~GrGLSLFragmentBuilder() {}
     /**
      * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
         kStandardDerivatives_GLSLFeature = 0,
         kLastGLSLFeature = kStandardDerivatives_GLSLFeature
     };
 
     /**
@@ skipping 46 matching lines @@
      * procs so no duplicate uniforms/functions appear in the generated shader program. The mangle
      * string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0],
      * then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will
      * have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's
      * 1st child's 2nd child".
      */
     SkString fMangleString;
 
     friend class GrGLPathProcessor;
 
-    typedef GrGLShaderBuilder INHERITED;
+    typedef GrGLSLShaderBuilder INHERITED;
 };
 
 /*
  * Fragment processor's, in addition to all of the above, may need to use dst color so they use
  * this builder to create their shader.  Because this is the only shader builder the FP sees, we
  * just call it FPShaderBuilder
  */
-class GrGLXPFragmentBuilder : public GrGLFragmentBuilder {
+class GrGLSLXPFragmentBuilder : public GrGLSLFragmentBuilder {
 public:
-    GrGLXPFragmentBuilder(GrGLSLProgramBuilder* program) : INHERITED(program) {}
+    GrGLSLXPFragmentBuilder(GrGLSLProgramBuilder* program) : INHERITED(program) {}
 
     /** Returns the variable name that holds the color of the destination pixel. This may be nullptr if
         no effect advertised that it will read the destination. */
     virtual const char* dstColor() = 0;
 
     /** Adds any necessary layout qualifiers in order to legalize the supplied blend equation with
         this shader. It is only legal to call this method with an advanced blend equation, and only
         if these equations are supported. */
     virtual void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) = 0;
 
 private:
-    typedef GrGLFragmentBuilder INHERITED;
+    typedef GrGLSLFragmentBuilder INHERITED;
 };
 
 // TODO rename to Fragment Builder
-class GrGLFragmentShaderBuilder : public GrGLXPFragmentBuilder {
+class GrGLSLFragmentShaderBuilder : public GrGLSLXPFragmentBuilder {
 public:
     typedef uint8_t FragPosKey;
 
     /** 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);
 
-    GrGLFragmentShaderBuilder(GrGLSLProgramBuilder* program, uint8_t fragPosKey);
+    GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* 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;
 
@@ skipping 17 matching lines @@
     static const char* DeclaredSecondaryColorOutputName() { return "fsSecondaryColorOut"; }
 
     /*
      * An internal call for GrGLProgramBuilder to use to add varyings to the vertex shader
      */
     void addVarying(GrGLSLVarying*, GrSLPrecision);
 
     void onFinalize() override;
 
     /**
-     * Features that should only be enabled by GrGLFragmentShaderBuilder itself.
+     * Features that should only be enabled by GrGLSLFragmentShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kBlendEquationAdvanced_GLSLPrivateFeature,
         kBlendFuncExtended_GLSLPrivateFeature,
         kLastGLSLPrivateFeature = kBlendFuncExtended_GLSLPrivateFeature
     };
 
     // 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 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;
+    typedef GrGLSLXPFragmentBuilder INHERITED;
 };
 
 #endif