Use SkTHashMap in SkGlyphCache.

src/core/SkGlyphCache.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGlyphCache_DEFINED
 #define SkGlyphCache_DEFINED
 
 #include "SkBitmap.h"
 #include "SkChecksum.h"
 #include "SkChunkAlloc.h"
 #include "SkDescriptor.h"
 #include "SkGlyph.h"
 #include "SkScalerContext.h"
+#include "SkTDArray.h"
+#include "SkTHash.h"
 #include "SkTemplates.h"
-#include "SkTDArray.h"
 
 struct SkDeviceProperties;
 class SkPaint;
 
 class SkGlyphCache_Globals;
 
-// Enable this locally to add stats for hash-table hit rates. It also extends the dump()
-// output to show those stats.
-//#define SK_GLYPHCACHE_TRACK_HASH_STATS
-
 /** \class SkGlyphCache
 
     This class represents a strike: a specific combination of typeface, size,
     matrix, etc., and holds the glyphs for that strike. Calling any of the
     getUnichar.../getGlyphID... methods will return the requested glyph,
     either instantly if it is already cached, or by first generating it and then
     adding it to the strike.
 
     The strikes are held in a global list, available to all threads. To interact
     with one, call either VisitCache() or DetachCache().
@@ skipping 149 matching lines @@
     };
 
     SkGlyph* lookupMetrics(uint32_t id, MetricsType);
     static bool DetachProc(const SkGlyphCache*, void*) { return true; }
 
     SkGlyphCache*       fNext, *fPrev;
     SkDescriptor*       fDesc;
     SkScalerContext*    fScalerContext;
     SkPaint::FontMetrics fFontMetrics;
 
-    enum {
-        kHashBits   = 8,
-        kHashCount  = 1 << kHashBits,
-        kHashMask   = kHashCount - 1
-    };
-    SkGlyph*            fGlyphHash[kHashCount];
-    SkTDArray<SkGlyph*> fGlyphArray;
-    SkChunkAlloc        fGlyphAlloc;
+    static uint32_t HashGlyphID(uint32_t  glyphID) { return SkChecksum::CheapMix(glyphID); }
+    static uint32_t HashUnichar(SkUnichar unichar) { return SkChecksum::CheapMix(unichar); }
 
-    struct CharGlyphRec {
-        uint32_t    fID;    // unichar + subpixel
-        SkGlyph*    fGlyph;
-    };
-    // no reason to use the same kHashCount as fGlyphHash, but we do for now
-    // Dynamically allocated when chars are encountered.
-    SkAutoTArray<CharGlyphRec> fCharToGlyphHash;
-    
-    CharGlyphRec* getCharGlyphRec(uint32_t id);
+    SkTHashMap<uint32_t,   SkGlyph, HashGlyphID> fGlyphs;
+    SkTHashMap<SkUnichar, uint16_t, HashUnichar> fCharToGlyphID;
 
-    static inline unsigned ID2HashIndex(uint32_t h) {
-        return SkChecksum::CheapMix(h) & kHashMask;
-    }
+    SkChunkAlloc        fAlloc;
 
     // used to track (approx) how much ram is tied-up in this cache
     size_t  fMemoryUsed;
 
-
-#ifdef SK_GLYPHCACHE_TRACK_HASH_STATS
-    int fHashHitCount;
-    int fHashMissCount;
-#endif
-
     struct AuxProcRec {
         AuxProcRec* fNext;
         void (*fProc)(void*);
         void* fData;
     };
     AuxProcRec* fAuxProcList;
     void invokeAndRemoveAuxProcs();
 
     inline static SkGlyphCache* FindTail(SkGlyphCache* head);
 
@@ skipping 64 matching lines @@
                             const SkMatrix* matrix) {
         fCache = paint.detachCache(deviceProperties, matrix, true);
     }
 
 private:
     SkAutoGlyphCacheNoGamma() : SkAutoGlyphCacheBase() {}
 };
 #define SkAutoGlyphCacheNoGamma(...) SK_REQUIRE_LOCAL_VAR(SkAutoGlyphCacheNoGamma)
 
 #endif