Replace use of GrTHashTable in GrFontCache with SkTDynamicHash.

src/gpu/GrTextStrike.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrTextStrike.h"
@@ skipping 21 matching lines @@
 GrFontCache::GrFontCache(GrGpu* gpu) : fGpu(gpu) {
     gpu->ref();
     for (int i = 0; i < kAtlasCount; ++i) {
         fAtlases[i] = NULL;
     }
 
     fHead = fTail = NULL;
 }
 
 GrFontCache::~GrFontCache() {
-    fCache.deleteAll();
+    SkTDynamicHash<GrTextStrike, GrFontDescKey>::Iter iter(&fCache);
+    while (!iter.done()) {
+        SkDELETE(&(*iter));
+        ++iter;
+    }
     for (int i = 0; i < kAtlasCount; ++i) {
         delete fAtlases[i];
     }
     fGpu->unref();
 #if FONT_CACHE_STATS
       GrPrintf("Num purges: %d\n", g_PurgeCount);
 #endif
 }
 
 static GrPixelConfig mask_format_to_pixel_config(GrMaskFormat format) {
@@ skipping 14 matching lines @@
         GrFontCache::k565_AtlasType,
         GrFontCache::k8888_AtlasType,
         GrFontCache::k8888_AtlasType
     };
     SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
 
     SkASSERT(sAtlasIndices[format] < GrFontCache::kAtlasCount);
     return sAtlasIndices[format];
 }
 
-GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler,
-                                          const Key& key) {
+GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler) {
     GrMaskFormat format = scaler->getMaskFormat();
     GrPixelConfig config = mask_format_to_pixel_config(format);
     int atlasIndex = mask_format_to_atlas_index(format);
     if (NULL == fAtlases[atlasIndex]) {
         SkISize textureSize = SkISize::Make(GR_ATLAS_TEXTURE_WIDTH,
                                             GR_ATLAS_TEXTURE_HEIGHT);
         fAtlases[atlasIndex] = SkNEW_ARGS(GrAtlas, (fGpu, config, kNone_GrTextureFlags,
                                                     textureSize,
                                                     GR_NUM_PLOTS_X,
                                                     GR_NUM_PLOTS_Y,
                                                     true));
     }
     GrTextStrike* strike = SkNEW_ARGS(GrTextStrike,
                                       (this, scaler->getKey(), format, fAtlases[atlasIndex]));
-    fCache.insert(key, strike);
+    fCache.add(strike);
 
     if (fHead) {
         fHead->fPrev = strike;
     } else {
         SkASSERT(NULL == fTail);
         fTail = strike;
     }
     strike->fPrev = NULL;
     strike->fNext = fHead;
     fHead = strike;
 
     return strike;
 }
 
 void GrFontCache::freeAll() {
-    fCache.deleteAll();
+    SkTDynamicHash<GrTextStrike, GrFontDescKey>::Iter iter(&fCache);
+    while (!iter.done()) {
+        SkDELETE(&(*iter));
+        ++iter;
+    }
+    fCache.rewind();
     for (int i = 0; i < kAtlasCount; ++i) {
         delete fAtlases[i];
         fAtlases[i] = NULL;
     }
     fHead = NULL;
     fTail = NULL;
 }
 
 void GrFontCache::purgeStrike(GrTextStrike* strike) {
-    const GrFontCache::Key key(strike->fFontScalerKey);
-    fCache.remove(key, strike);
+    fCache.remove(*(strike->fFontScalerKey));
     this->detachStrikeFromList(strike);
     delete strike;
 }
 
 bool GrFontCache::freeUnusedPlot(GrTextStrike* preserveStrike) {
     SkASSERT(NULL != preserveStrike);
 
     GrAtlas* atlas = preserveStrike->fAtlas;
     GrPlot* plot = atlas->getUnusedPlot();
     if (NULL == plot) {
@@ skipping 99 matching lines @@
     fAtlas = atlas;         // no need to ref, it won't go away before we do
 
     fMaskFormat = format;
 
 #ifdef SK_DEBUG
 //    GrPrintf(" GrTextStrike %p %d\n", this, gCounter);
     gCounter += 1;
 #endif
 }
 
-// this signature is needed because it's used with
-// SkTDArray::visitAll() (see destructor)
-static void free_glyph(GrGlyph*& glyph) { glyph->free(); }
-
 GrTextStrike::~GrTextStrike() {
     fFontScalerKey->unref();
-    fCache.getArray().visitAll(free_glyph);
+    SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
+    while (!iter.done()) {
+        (*iter).free();
+        ++iter;
+    }
 
 #ifdef SK_DEBUG
     gCounter -= 1;
 //    GrPrintf("~GrTextStrike %p %d\n", this, gCounter);
 #endif
 }
 
 GrGlyph* GrTextStrike::generateGlyph(GrGlyph::PackedID packed,
                                      GrFontScaler* scaler) {
     SkIRect bounds;
     if (fUseDistanceField) {
         if (!scaler->getPackedGlyphDFBounds(packed, &bounds)) {
             return NULL;
         }
     } else {
         if (!scaler->getPackedGlyphBounds(packed, &bounds)) {
             return NULL;
         }
     }
 
     GrGlyph* glyph = fPool.alloc();
     glyph->init(packed, bounds);
-    fCache.insert(packed, glyph);
+    fCache.add(glyph);
     return glyph;
 }
 
 void GrTextStrike::removePlot(const GrPlot* plot) {
-    SkTDArray<GrGlyph*>& glyphArray = fCache.getArray();
-    for (int i = 0; i < glyphArray.count(); ++i) {
-        if (plot == glyphArray[i]->fPlot) {
-            glyphArray[i]->fPlot = NULL;
+    SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
+    while (!iter.done()) {
+        if (plot == (*iter).fPlot) {
+            (*iter).fPlot = NULL;
         }
+        ++iter;
     }
 
     GrAtlas::RemovePlot(&fPlotUsage, plot);
 }
 
 
 bool GrTextStrike::addGlyphToAtlas(GrGlyph* glyph, GrFontScaler* scaler) {
 #if 0   // testing hack to force us to flush our cache often
     static int gCounter;
     if ((++gCounter % 10) == 0) return false;
 #endif
 
     SkASSERT(glyph);
     SkASSERT(scaler);
-    SkASSERT(fCache.contains(glyph));
+    SkASSERT(fCache.find(glyph->fPackedID));
     SkASSERT(NULL == glyph->fPlot);
 
     SkAutoUnref ar(SkSafeRef(scaler));
 
     int bytesPerPixel = GrMaskFormatBytesPerPixel(fMaskFormat);
 
     size_t size = glyph->fBounds.area() * bytesPerPixel;
     SkAutoSMalloc<1024> storage(size);
     if (fUseDistanceField) {
         if (!scaler->getPackedGlyphDFImage(glyph->fPackedID, glyph->width(),
@@ skipping 14 matching lines @@
                                        glyph->height(), storage.get(),
                                        &glyph->fAtlasLocation);
 
     if (NULL == plot) {
         return false;
     }
 
     glyph->fPlot = plot;
     return true;
 }