Changes to remove program effects builder

src/gpu/gl/builders/GrGLVertexShaderBuilder.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 "GrGLVertexShaderBuilder.h"
 #include "GrGLFullProgramBuilder.h"
 #include "GrGLShaderStringBuilder.h"
@@ skipping 100 matching lines @@
 
 bool GrGLVertexShaderBuilder::compileAndAttachShaders(GrGLuint programId,
         SkTDArray<GrGLuint>* shaderIds) const {
     GrGpuGL* gpu = fProgramBuilder->gpu();
     const GrGLContext& glCtx = gpu->glContext();
     const GrGLContextInfo& ctxInfo = gpu->ctxInfo();
     SkString vertShaderSrc(GrGetGLSLVersionDecl(ctxInfo));
     fProgramBuilder->appendUniformDecls(GrGLProgramBuilder::kVertex_Visibility, &vertShaderSrc);
     fProgramBuilder->appendDecls(fInputs, &vertShaderSrc);
     fProgramBuilder->appendDecls(fOutputs, &vertShaderSrc);
-    vertShaderSrc.append("void main() {\n");
+    vertShaderSrc.append("void main() {");
     vertShaderSrc.append(fCode);
-    vertShaderSrc.append("}\n");
+    vertShaderSrc.append("}");
     GrGLuint vertShaderId = GrGLCompileAndAttachShader(glCtx, programId,
             GR_GL_VERTEX_SHADER, vertShaderSrc);
     if (!vertShaderId) {
         return false;
     }
     *shaderIds->append() = vertShaderId;
     return true;
 }
 
 void GrGLVertexShaderBuilder::emitCodeAfterEffects() {
     const char* rtAdjustName;
     fProgramBuilder->fUniformHandles.fRTAdjustmentUni =
         fProgramBuilder->addUniform(GrGLProgramBuilder::kVertex_Visibility,
                              kVec4f_GrSLType,
                              "rtAdjustment",
                              &rtAdjustName);
 
     // Transform from Skia's device coords to GL's normalized device coords.
     this->codeAppendf(
-        "\tgl_Position = vec4(dot(pos3.xz, %s.xy), dot(pos3.yz, %s.zw), 0, pos3.z);\n",
+        "gl_Position = vec4(dot(pos3.xz, %s.xy), dot(pos3.yz, %s.zw), 0, pos3.z);",
         rtAdjustName, rtAdjustName);
 }
 
 void GrGLVertexShaderBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) {
     const GrGLProgramDesc::KeyHeader& header = fProgramBuilder->desc().getHeader();
 
     fPositionVar = &fInputs.push_back();
-    fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, "aPosition");
+    fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, "inPosition");
     if (-1 != header.fLocalCoordAttributeIndex) {
         fLocalCoordsVar = &fInputs.push_back();
         fLocalCoordsVar->set(kVec2f_GrSLType,
                              GrGLShaderVar::kAttribute_TypeModifier,
-                             "aLocalCoords");
+                             "inLocalCoords");
     } else {
         fLocalCoordsVar = fPositionVar;
     }
 
     const char* viewMName;
     fProgramBuilder->fUniformHandles.fViewMatrixUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kVertex_Visibility,
                                  kMat33f_GrSLType,
                                  "ViewM",
                                  &viewMName);
 
     // Transform the position into Skia's device coords.
-    this->codeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n",
+    this->codeAppendf("vec3 pos3 = %s * vec3(%s, 1);",
                       viewMName, fPositionVar->c_str());
 
     // we output point size in the GS if present
     if (header.fEmitsPointSize
 #if GR_GL_EXPERIMENTAL_GS
         && !header.fExperimentalGS
 #endif
         ) {
-        this->codeAppend("\tgl_PointSize = 1.0;\n");
+        this->codeAppend("gl_PointSize = 1.0;");
     }
 
     if (GrGLProgramDesc::kAttribute_ColorInput == header.fColorInput) {
         this->addAttribute(GrShaderVar(color_attribute_name(),
                                        kVec4f_GrSLType,
                                        GrShaderVar::kAttribute_TypeModifier));
         const char *vsName, *fsName;
         fFullProgramBuilder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
-        this->codeAppendf("\t%s = %s;\n", vsName, color_attribute_name());
+        this->codeAppendf("%s = %s;", vsName, color_attribute_name());
         *color = fsName;
     }
 
     if (GrGLProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
         this->addAttribute(GrShaderVar(coverage_attribute_name(),
                                        kVec4f_GrSLType,
                                        GrShaderVar::kAttribute_TypeModifier));
         const char *vsName, *fsName;
         fFullProgramBuilder->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
-        this->codeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
+        this->codeAppendf("%s = %s;", vsName, coverage_attribute_name());
         *coverage = fsName;
     }
     fEffectAttribOffset = fInputs.count();
 }