Rename GrGpuGL to GrGLGpu for consistency

tests/GLProgramsTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
@@ skipping 121 matching lines @@
 static const GrGeometryProcessor* get_random_gp(GrContext* context,
                                                 const GrDrawTargetCaps& caps,
                                                 SkRandom* random,
                                                 GrTexture* dummyTextures[]) {
     return GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(random,
                                                                     context,
                                                                     caps,
                                                                     dummyTextures);
 }
 
-static void set_random_color_coverage_stages(GrGpuGL* gpu,
+static void set_random_color_coverage_stages(GrGLGpu* gpu,
                                              GrDrawState* ds,
                                              int maxStages,
                                              bool usePathRendering,
                                              SkRandom* random,
                                              GrTexture* dummyTextures[]) {
     int numProcs = random->nextULessThan(maxStages + 1);
     int numColorProcs = random->nextULessThan(numProcs + 1);
 
     int currTextureCoordSet = 0;
     for (int s = 0; s < numProcs;) {
@@ skipping 57 matching lines @@
                                  0xffff);
 
     if (random->nextBool()) {
         ds->setStencil(kDoesWriteStencil);
     } else {
         ds->setStencil(kDoesNotWriteStencil);
     }
 }
 
 bool GrDrawTarget::programUnitTest(int maxStages) {
-    GrGpuGL* gpu = static_cast<GrGpuGL*>(fContext->getGpu());
+    GrGLGpu* gpu = static_cast<GrGLGpu*>(fContext->getGpu());
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
     dummyDesc.fWidth = 34;
     dummyDesc.fHeight = 18;
     SkAutoTUnref<GrTexture> dummyTexture1(gpu->createTexture(dummyDesc, NULL, 0));
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
     dummyDesc.fWidth = 16;
@@ skipping 101 matching lines @@
         // want to increment on success
         ++t;
     }
     return true;
 }
 
 DEF_GPUTEST(GLPrograms, reporter, factory) {
     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
         GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(type));
         if (context) {
-            GrGpuGL* gpu = static_cast<GrGpuGL*>(context->getGpu());
+            GrGLGpu* gpu = static_cast<GrGLGpu*>(context->getGpu());
 
             /*
              * For the time being, we only support the test with desktop GL or for android on
              * ARM platforms
              * TODO When we run ES 3.00 GLSL in more places, test again
              */
             int maxStages;
             if (kGL_GrGLStandard == gpu->glStandard() ||
                 kARM_GrGLVendor == gpu->ctxInfo().vendor()) {
                 maxStages = 6;
@@ skipping 10 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif