Replace use of GrTHashTable in GrFontCache with SkTDynamicHash.

src/gpu/GrTextStrike.h

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #ifndef GrTextStrike_DEFINED
 #define GrTextStrike_DEFINED
 
 #include "GrAllocPool.h"
 #include "GrFontScaler.h"
-#include "GrTHashTable.h"
+#include "SkTDynamicHash.h"
 #include "GrGlyph.h"
 #include "GrDrawTarget.h"
 #include "GrAtlas.h"
 
 class GrFontCache;
 class GrGpu;
 class GrFontPurgeListener;
 
 /**
  *  The textcache maps a hostfontscaler instance to a dictionary of
  *  glyphid->strike
  */
 class GrTextStrike {
 public:
     GrTextStrike(GrFontCache*, const GrFontDescKey* fontScalerKey, GrMaskFormat, GrAtlas*);
     ~GrTextStrike();
 
     const GrFontDescKey* getFontScalerKey() const { return fFontScalerKey; }
     GrFontCache* getFontCache() const { return fFontCache; }
     GrMaskFormat getMaskFormat() const { return fMaskFormat; }
 
     inline GrGlyph* getGlyph(GrGlyph::PackedID, GrFontScaler*);
     bool addGlyphToAtlas(GrGlyph*, GrFontScaler*);
 
     // testing
-    int countGlyphs() const { return fCache.getArray().count(); }
-    const GrGlyph* glyphAt(int index) const {
-        return fCache.getArray()[index];
-    }
+    int countGlyphs() const { return fCache.count(); }
 
     // remove any references to this plot
     void removePlot(const GrPlot* plot);
 
+    static const GrFontDescKey& GetKey(const GrTextStrike& ts) {
+        return *(ts.fFontScalerKey);
+    }
+    static uint32_t Hash(const GrFontDescKey& key) {
+        return key.getHash();
+    }
+
 public:
     // for easy removal from list
     GrTextStrike*   fPrev;
     GrTextStrike*   fNext;
 
 private:
-    class Key;
-    GrTHashTable<GrGlyph, Key, 7> fCache;
+    SkTDynamicHash<GrGlyph, GrGlyph::PackedID> fCache;
     const GrFontDescKey* fFontScalerKey;
     GrTAllocPool<GrGlyph> fPool;
 
     GrFontCache*    fFontCache;
     GrAtlas*        fAtlas;
     GrMaskFormat    fMaskFormat;
     bool            fUseDistanceField;
 
     GrAtlas::ClientPlotUsage fPlotUsage;
 
     GrGlyph* generateGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler);
 
     friend class GrFontCache;
 };
 
 class GrFontCache {
 public:
     GrFontCache(GrGpu*);
     ~GrFontCache();
 
     inline GrTextStrike* getStrike(GrFontScaler*, bool useDistanceField);
 
     void freeAll();
 
     // make an unused plot available
     bool freeUnusedPlot(GrTextStrike* preserveStrike);
 
     // testing
-    int countStrikes() const { return fCache.getArray().count(); }
-    const GrTextStrike* strikeAt(int index) const {
-        return fCache.getArray()[index];
-    }
+    int countStrikes() const { return fCache.count(); }
     GrTextStrike* getHeadStrike() const { return fHead; }
 
     void updateTextures() {
         for (int i = 0; i < kAtlasCount; ++i) {
             if (fAtlases[i]) {
                 fAtlases[i]->uploadPlotsToTexture();
             }
         }
     }
 
@@ skipping 10 matching lines @@
         k565_AtlasType,  //!< 2-bytes per pixel
         k8888_AtlasType, //!< 4-bytes per pixel
 
         kLast_AtlasType = k8888_AtlasType
     };
     static const int kAtlasCount = kLast_AtlasType + 1;
 
 private:
     friend class GrFontPurgeListener;
 
-    class Key;
-    GrTHashTable<GrTextStrike, Key, 8> fCache;
+    SkTDynamicHash<GrTextStrike, GrFontDescKey> fCache;
     // for LRU
     GrTextStrike* fHead;
     GrTextStrike* fTail;
 
     GrGpu*      fGpu;
     GrAtlas*    fAtlases[kAtlasCount];
 
-    GrTextStrike* generateStrike(GrFontScaler*, const Key&);
+    GrTextStrike* generateStrike(GrFontScaler*);
     inline void detachStrikeFromList(GrTextStrike*);
     void purgeStrike(GrTextStrike* strike);
 };
 
 #endif