Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/GrGpuGL_program.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.
  */
 
 #include "GrGpuGL.h"
 
 #include "builders/GrGLProgramBuilder.h"
 #include "GrProcessor.h"
 #include "GrGLProcessor.h"
 #include "GrGLPathRendering.h"
 #include "GrOptDrawState.h"
 #include "SkRTConf.h"
 #include "SkTSearch.h"
 
 #ifdef PROGRAM_CACHE_STATS
 SK_CONF_DECLARE(bool, c_DisplayCache, "gpu.displayCache", false,
                 "Display program cache usage.");
 #endif
 
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
-struct GrGpuGL::ProgramCache::Entry {
+struct GrGLGpu::ProgramCache::Entry {
     SK_DECLARE_INST_COUNT_ROOT(Entry);
     Entry() : fProgram(NULL), fLRUStamp(0) {}
 
     SkAutoTUnref<GrGLProgram>   fProgram;
     unsigned int                fLRUStamp;
 };
 
-struct GrGpuGL::ProgramCache::ProgDescLess {
+struct GrGLGpu::ProgramCache::ProgDescLess {
     bool operator() (const GrProgramDesc& desc, const Entry* entry) {
         SkASSERT(entry->fProgram.get());
         return GrProgramDesc::Less(desc, entry->fProgram->getDesc());
     }
 
     bool operator() (const Entry* entry, const GrProgramDesc& desc) {
         SkASSERT(entry->fProgram.get());
         return GrProgramDesc::Less(entry->fProgram->getDesc(), desc);
     }
 };
 
-GrGpuGL::ProgramCache::ProgramCache(GrGpuGL* gpu)
+GrGLGpu::ProgramCache::ProgramCache(GrGLGpu* gpu)
     : fCount(0)
     , fCurrLRUStamp(0)
     , fGpu(gpu)
 #ifdef PROGRAM_CACHE_STATS
     , fTotalRequests(0)
     , fCacheMisses(0)
     , fHashMisses(0)
 #endif
 {
     for (int i = 0; i < 1 << kHashBits; ++i) {
         fHashTable[i] = NULL;
     }
 }
 
-GrGpuGL::ProgramCache::~ProgramCache() {
+GrGLGpu::ProgramCache::~ProgramCache() {
     for (int i = 0; i < fCount; ++i){
         SkDELETE(fEntries[i]);
     }
     // dump stats
 #ifdef PROGRAM_CACHE_STATS
     if (c_DisplayCache) {
         SkDebugf("--- Program Cache ---\n");
         SkDebugf("Total requests: %d\n", fTotalRequests);
         SkDebugf("Cache misses: %d\n", fCacheMisses);
         SkDebugf("Cache miss %%: %f\n", (fTotalRequests > 0) ?
                                             100.f * fCacheMisses / fTotalRequests :
                                             0.f);
         int cacheHits = fTotalRequests - fCacheMisses;
         SkDebugf("Hash miss %%: %f\n", (cacheHits > 0) ? 100.f * fHashMisses / cacheHits : 0.f);
         SkDebugf("---------------------\n");
     }
 #endif
 }
 
-void GrGpuGL::ProgramCache::abandon() {
+void GrGLGpu::ProgramCache::abandon() {
     for (int i = 0; i < fCount; ++i) {
         SkASSERT(fEntries[i]->fProgram.get());
         fEntries[i]->fProgram->abandon();
         SkDELETE(fEntries[i]);
     }
     fCount = 0;
 }
 
-int GrGpuGL::ProgramCache::search(const GrProgramDesc& desc) const {
+int GrGLGpu::ProgramCache::search(const GrProgramDesc& desc) const {
     ProgDescLess less;
     return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
 }
 
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState) {
+GrGLProgram* GrGLGpu::ProgramCache::getProgram(const GrOptDrawState& optState) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
     uint32_t hashIdx = optState.programDesc().getChecksum();
     hashIdx ^= hashIdx >> 16;
     if (kHashBits <= 8) {
         hashIdx ^= hashIdx >> 8;
@@ skipping 84 matching lines @@
 
     if (SK_MaxU32 == fCurrLRUStamp) {
         // wrap around! just trash our LRU, one time hit.
         for (int i = 0; i < fCount; ++i) {
             fEntries[i]->fLRUStamp = 0;
         }
     }
     ++fCurrLRUStamp;
     return entry->fProgram;
 }