Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/GrGLPath.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 "GrGLPath.h"
 #include "GrGLPathRendering.h"
@@ skipping 72 matching lines @@
                              GrGLfloat coords[]) {
     for (size_t i = 0;  i < amount; ++i) {
         coords[i * 2] =  SkScalarToFloat(points[first_point + i].fX);
         coords[i * 2 + 1] = SkScalarToFloat(points[first_point + i].fY);
     }
 }
 }
 
 static const bool kIsWrapped = false; // The constructor creates the GL path object.
 
-void GrGLPath::InitPathObject(GrGpuGL* gpu,
+void GrGLPath::InitPathObject(GrGLGpu* gpu,
                               GrGLuint pathID,
                               const SkPath& skPath,
                               const SkStrokeRec& stroke) {
     if (!skPath.isEmpty()) {
         int verbCnt = skPath.countVerbs();
         int pointCnt = skPath.countPoints();
         int minCoordCnt = pointCnt * 2;
 
         SkSTArray<16, GrGLubyte, true> pathCommands(verbCnt);
         SkSTArray<16, GrGLfloat, true> pathCoords(minCoordCnt);
@@ skipping 72 matching lines @@
             PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
         GR_GL_CALL(gpu->glInterface(),
             PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(stroke.getMiter())));
         GrGLenum join = join_to_gl_join(stroke.getJoin());
         GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_JOIN_STYLE, join));
         GrGLenum cap = cap_to_gl_cap(stroke.getCap());
         GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_END_CAPS, cap));
     }
 }
 
-GrGLPath::GrGLPath(GrGpuGL* gpu, const SkPath& path, const SkStrokeRec& stroke)
+GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& path, const SkStrokeRec& stroke)
     : INHERITED(gpu, kIsWrapped, path, stroke),
       fPathID(gpu->glPathRendering()->genPaths(1)) {
 
     InitPathObject(gpu, fPathID, fSkPath, stroke);
 
     if (stroke.needToApply()) {
         // FIXME: try to account for stroking, without rasterizing the stroke.
         fBounds.outset(stroke.getWidth(), stroke.getWidth());
     }
     this->registerWithCache();
 }
 
 void GrGLPath::onRelease() {
     if (0 != fPathID && !this->isWrapped()) {
-        static_cast<GrGpuGL*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
+        static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
         fPathID = 0;
     }
 
     INHERITED::onRelease();
 }
 
 void GrGLPath::onAbandon() {
     fPathID = 0;
 
     INHERITED::onAbandon();
 }