Revert of Multi-string shaders

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/GrGLProcessor.h"
 #include "gl/GrGLProgramDesc.h"
 #include "gl/GrGLProgramDataManager.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrGLProgramBuilder;
 
 /**
@@ skipping 45 matching lines @@
     /** 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);
+       fCode.appendVAList(format, args);
        va_end(args);
     }
 
-    void codeAppend(const char* str) { this->code().append(str); }
+    void codeAppend(const char* str) { fCode.append(str); }
 
     void codePrependf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
        va_list args;
        va_start(args, format);
-       this->code().prependVAList(format, args);
+       fCode.prependVAList(format, args);
        va_end(args);
     }
 
     /**
      * Appends a variable declaration to one of the shaders
      */
     void declAppend(const GrGLShaderVar& var);
 
     /** Emits a helper function outside of main() in the fragment shader. */
     void emitFunction(GrSLType returnType,
@@ skipping 35 matching lines @@
     void appendTextureLookup(const char* samplerName,
                              const char* coordName,
                              uint32_t configComponentMask,
                              const char* swizzle);
 
     /*
      * A general function which enables an extension in a shader if the feature bit is not present
      */
     void addFeature(uint32_t featureBit, const char* extensionName);
 
-    void nextStage() {
-        fShaderStrings.push_back();
-        fCompilerStrings.push_back(this->code().c_str());
-        fCompilerStringLengths.push_back(this->code().size());
-        fCodeIndex++;
-    }
+    GrGLProgramBuilder* fProgramBuilder;
 
-    SkString& versionDecl() { return fShaderStrings[kVersionDecl]; }
-    SkString& extensions() { return fShaderStrings[kExtensions]; }
-    SkString& precisionQualifier() { return fShaderStrings[kPrecisionQualifier]; }
-    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);
-
-    enum {
-        kVersionDecl,
-        kExtensions,
-        kPrecisionQualifier,
-        kUniforms,
-        kInputs,
-        kOutputs,
-        kFunctions,
-        kMain,
-        kCode,
-    };
-
-    GrGLProgramBuilder* fProgramBuilder;
-    SkSTArray<kCode, const char*, true> fCompilerStrings;
-    SkSTArray<kCode, int, true> fCompilerStringLengths;
-    SkSTArray<kCode, SkString> fShaderStrings;
     SkString fCode;
     SkString fFunctions;
     SkString fExtensions;
 
     VarArray fInputs;
     VarArray fOutputs;
     uint32_t fFeaturesAddedMask;
-    int fCodeIndex;
-    bool fFinalized;
-
-    friend class GrGLProgramBuilder;
 };
 #endif