Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/builders/GrGLFragmentShaderBuilder.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 "GrGLFragmentShaderBuilder.h"
 #include "GrGLShaderStringBuilder.h"
 #include "GrGLProgramBuilder.h"
@@ skipping 61 matching lines @@
     , fSetupFragPosition(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == fragPosKey)
     , fCustomColorOutputIndex(-1)
     , fHasReadDstColor(false)
     , fHasReadFragmentPosition(false) {
 }
 
 bool GrGLFragmentShaderBuilder::enableFeature(GLSLFeature feature) {
     switch (feature) {
         case kStandardDerivatives_GLSLFeature: {
-            GrGpuGL* gpu = fProgramBuilder->gpu();
+            GrGLGpu* gpu = fProgramBuilder->gpu();
             if (!gpu->glCaps().shaderDerivativeSupport()) {
                 return false;
             }
             if (kGLES_GrGLStandard == gpu->glStandard() &&
                 k110_GrGLSLGeneration == gpu->glslGeneration()) {
                 this->addFeature(1 << kStandardDerivatives_GLSLFeature,
                                  "GL_OES_standard_derivatives");
             }
             return true;
         }
@@ skipping 15 matching lines @@
         coords2D.appendf("_%i", index);
     }
     this->codeAppendf("\tvec2 %s = %s.xy / %s.z;",
                       coords2D.c_str(), coords[index].c_str(), coords[index].c_str());
     return coords2D;
 }
 
 const char* GrGLFragmentShaderBuilder::fragmentPosition() {
     fHasReadFragmentPosition = true;
 
-    GrGpuGL* gpu = fProgramBuilder->gpu();
+    GrGLGpu* gpu = fProgramBuilder->gpu();
     // We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers
     // to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the
     // declaration varies in earlier GLSL specs. So it is simpler to omit it.
     if (fTopLeftFragPosRead) {
         fSetupFragPosition = true;
         return "gl_FragCoord";
     } else if (gpu->glCaps().fragCoordConventionsSupport()) {
         if (!fSetupFragPosition) {
             if (gpu->glslGeneration() < k150_GrGLSLGeneration) {
                 this->addFeature(1 << kFragCoordConventions_GLSLPrivateFeature,
@@ skipping 30 matching lines @@
             fSetupFragPosition = true;
         }
         SkASSERT(fProgramBuilder->fUniformHandles.fRTHeightUni.isValid());
         return kCoordName;
     }
 }
 
 const char* GrGLFragmentShaderBuilder::dstColor() {
     fHasReadDstColor = true;
 
-    GrGpuGL* gpu = fProgramBuilder->gpu();
+    GrGLGpu* gpu = fProgramBuilder->gpu();
     if (gpu->glCaps().fbFetchSupport()) {
         this->addFeature(1 << (GrGLFragmentShaderBuilder::kLastGLSLPrivateFeature + 1),
                          gpu->glCaps().fbFetchExtensionString());
 
         // On ES 3.0 we have to declare this, and use the custom color output name
         const char* fbFetchColorName = gpu->glCaps().fbFetchColorName();
         if (gpu->glslGeneration() >= k330_GrGLSLGeneration) {
             this->enableCustomOutput();
             fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier);
             fbFetchColorName = declared_color_output_name();
@@ skipping 71 matching lines @@
 const char* GrGLFragmentShaderBuilder::getPrimaryColorOutputName() const {
     return fHasCustomColorOutput ? declared_color_output_name() : "gl_FragColor";
 }
 
 const char* GrGLFragmentShaderBuilder::getSecondaryColorOutputName() const {
     return dual_source_output_name();
 }
 
 bool GrGLFragmentShaderBuilder::compileAndAttachShaders(GrGLuint programId,
                                                         SkTDArray<GrGLuint>* shaderIds) const {
-    GrGpuGL* gpu = fProgramBuilder->gpu();
+    GrGLGpu* gpu = fProgramBuilder->gpu();
     SkString fragShaderSrc(GrGetGLSLVersionDecl(gpu->ctxInfo()));
     fragShaderSrc.append(fExtensions);
     append_default_precision_qualifier(kDefault_GrSLPrecision,
                                        gpu->glStandard(),
                                        &fragShaderSrc);
     fProgramBuilder->appendUniformDecls(GrGLProgramBuilder::kFragment_Visibility, &fragShaderSrc);
     this->appendDecls(fInputs, &fragShaderSrc);
     // We shouldn't have declared outputs on 1.10
     SkASSERT(k110_GrGLSLGeneration != gpu->glslGeneration() || fOutputs.empty());
     this->appendDecls(fOutputs, &fragShaderSrc);
@@ skipping 25 matching lines @@
     }
 }
 
 void GrGLFragmentShaderBuilder::addVarying(GrGLVarying* v, GrSLPrecision fsPrec) {
     v->fFsIn = v->fVsOut;
     if (v->fGsOut) {
         v->fFsIn = v->fGsOut;
     }
     fInputs.push_back().set(v->fType, GrGLShaderVar::kVaryingIn_TypeModifier, v->fFsIn, fsPrec);
 }