Cleanup of shader building system

src/gpu/gl/GrGLProgramDataManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "gl/builders/GrGLProgramBuilder.h"
 #include "gl/GrGLPathRendering.h"
-#include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
 #include "gl/GrGpuGL.h"
 #include "SkMatrix.h"
 
 #define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT) \
          SkASSERT(arrayCount <= uni.fArrayCount || \
                   (1 == arrayCount && GrGLShaderVar::kNonArray == uni.fArrayCount))
 
-GrGLProgramDataManager::GrGLProgramDataManager(GrGpuGL* gpu,
-                                               GrGLProgram* program,
-                                               const GrGLProgramBuilder& builder)
-    : fGpu(gpu),
-      fProgram(program) {
-    int count = builder.getUniformInfos().count();
+GrGLProgramDataManager::GrGLProgramDataManager(GrGpuGL* gpu, const UniformInfoArray& uniforms)
+    : fGpu(gpu) {
+    int count = uniforms.count();
     fUniforms.push_back_n(count);
     for (int i = 0; i < count; i++) {
         Uniform& uniform = fUniforms[i];
-        const GrGLProgramBuilder::UniformInfo& builderUniform = builder.getUniformInfos()[i];
+        const UniformInfo& builderUniform = uniforms[i];
         SkASSERT(GrGLShaderVar::kNonArray == builderUniform.fVariable.getArrayCount() ||
                  builderUniform.fVariable.getArrayCount() > 0);
         SkDEBUGCODE(
             uniform.fArrayCount = builderUniform.fVariable.getArrayCount();
             uniform.fType = builderUniform.fVariable.getType();
         );
         // TODO: Move the Xoom uniform array in both FS and VS bug workaround here.
 
         if (GrGLProgramBuilder::kVertex_Visibility & builderUniform.fVisibility) {
             uniform.fVSLocation = builderUniform.fLocation;
         } else {
             uniform.fVSLocation = kUnusedUniform;
-            }
+        }
         if (GrGLProgramBuilder::kFragment_Visibility & builderUniform.fVisibility) {
             uniform.fFSLocation = builderUniform.fLocation;
         } else {
             uniform.fFSLocation = kUnusedUniform;
         }
     }
-
-    count = builder.getSeparableVaryingInfos().count();
-    fVaryings.push_back_n(count);
-    for (int i = 0; i < count; i++) {
-        Varying& varying = fVaryings[i];
-        const GrGLProgramBuilder::SeparableVaryingInfo& builderVarying =
-            builder.getSeparableVaryingInfos()[i];
-        SkASSERT(GrGLShaderVar::kNonArray == builderVarying.fVariable.getArrayCount());
-        SkDEBUGCODE(
-            varying.fType = builderVarying.fVariable.getType();
-        );
-        varying.fLocation = builderVarying.fLocation;
-    }
 }
 
 void GrGLProgramDataManager::setSampler(UniformHandle u, GrGLint texUnit) const {
     const Uniform& uni = fUniforms[u.toProgramDataIndex()];
     SkASSERT(uni.fType == kSampler2D_GrSLType);
     SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount);
     // FIXME: We still insert a single sampler uniform for every stage. If the shader does not
     // reference the sampler then the compiler may have optimized it out. Uncomment this assert
     // once stages insert their own samplers.
     // SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation);
@@ skipping 198 matching lines @@
         matrix.get(SkMatrix::kMPersp0),
         matrix.get(SkMatrix::kMSkewX),
         matrix.get(SkMatrix::kMScaleY),
         matrix.get(SkMatrix::kMPersp1),
         matrix.get(SkMatrix::kMTransX),
         matrix.get(SkMatrix::kMTransY),
         matrix.get(SkMatrix::kMPersp2),
     };
     this->setMatrix3f(u, mt);
 }
-
-void GrGLProgramDataManager::setProgramPathFragmentInputTransform(VaryingHandle i,
-                                                                  unsigned components,
-                                                                  const SkMatrix& matrix) const {
-    const Varying& fragmentInput = fVaryings[i.toProgramDataIndex()];
-    fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgram->programID(),
-                                                                  fragmentInput.fLocation,
-                                                                  GR_GL_OBJECT_LINEAR,
-                                                                  components,
-                                                                  matrix);
-}