Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 
 #include "GrAutoLocaleSetter.h"
 #include "GrCoordTransform.h"
 #include "GrGLProgramBuilder.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTraceEvent.h"
+#include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLXferProcessor.h"
+#include "gl/builders/GrGLShaderStringBuilder.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X)
 
 const int GrGLProgramBuilder::kVarsPerBlock = 8;
 
 GrGLProgram* GrGLProgramBuilder::CreateProgram(const DrawArgs& args, GrGLGpu* gpu) {
@@ skipping 342 matching lines @@
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
         localSamplerUniforms[t] = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                    kSampler2D_GrSLType, kDefault_GrSLPrecision,
                                                    name.c_str());
         SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLSLTextureSampler,
                                (localSamplerUniforms[t], processor.textureAccess(t)));
     }
 }
 
+bool GrGLProgramBuilder::compileAndAttachShaders(GrGLShaderBuilder& shader,
+                                                 GrGLuint programId,
+                                                 GrGLenum type,
+                                                 SkTDArray<GrGLuint>* shaderIds) {
+    GrGLGpu* gpu = this->gpu();
+    GrGLuint shaderId = GrGLCompileAndAttachShader(gpu->glContext(),
+                                                   programId,
+                                                   type,
+                                                   shader.fCompilerStrings.begin(),
+                                                   shader.fCompilerStringLengths.begin(),
+                                                   shader.fCompilerStrings.count(),
+                                                   gpu->stats());
+
+    if (!shaderId) {
+        return false;
+    }
+
+    *shaderIds->append() = shaderId;
+
+    return true;
+}
+
 GrGLProgram* GrGLProgramBuilder::finalize() {
     // verify we can get a program id
     GrGLuint programID;
     GL_CALL_RET(programID, CreateProgram());
     if (0 == programID) {
         return nullptr;
     }
 
     // compile shaders and bind attributes / uniforms
     SkTDArray<GrGLuint> shadersToDelete;
-
-    if (!fVS.compileAndAttachShaders(programID, &shadersToDelete)) {
+    fVS.finalize(kVertex_Visibility);
+    if (!this->compileAndAttachShaders(fVS, programID, GR_GL_VERTEX_SHADER, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
         return nullptr;
     }
 
     // NVPR actually requires a vertex shader to compile
     bool useNvpr = primitiveProcessor().isPathRendering();
     if (!useNvpr) {
         fVS.bindVertexAttributes(programID);
     }
 
-    if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
+    fFS.finalize(kFragment_Visibility);
+    if (!this->compileAndAttachShaders(fFS, programID, GR_GL_FRAGMENT_SHADER, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
         return nullptr;
     }
 
     this->bindProgramResourceLocations(programID);
 
     GL_CALL(LinkProgram(programID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = kChromium_GrGLDriver != fGpu->ctxInfo().driver();
@@ skipping 103 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }