patch from issue 885453002 at patchset 20001 (http://crrev.com/885453002#ps20001)

src/core/SkGlyphCache.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkGlyphCache.h"
@@ skipping 68 matching lines @@
     SkASSERT(desc);
     SkASSERT(ctx);
 
     fPrev = fNext = NULL;
 
     fDesc = desc->copy();
     fScalerContext->getFontMetrics(&fFontMetrics);
 
     // init to 0 so that all of the pointers will be null
     memset(fGlyphHash, 0, sizeof(fGlyphHash));
-    // init with 0xFF so that the charCode field will be -1, which is invalid
-    memset(fCharToGlyphHash, 0xFF, sizeof(fCharToGlyphHash));
-
+            
     fMemoryUsed = sizeof(*this);
 
     fGlyphArray.setReserve(kMinGlyphCount);
 
     fAuxProcList = NULL;
 }
 
 SkGlyphCache::~SkGlyphCache() {
 #if 0
     {
         size_t ptrMem = fGlyphArray.count() * sizeof(SkGlyph*);
         size_t glyphAlloc = fGlyphAlloc.totalCapacity();
         size_t glyphHashUsed = 0;
         size_t uniHashUsed = 0;
         for (int i = 0; i < kHashCount; ++i) {
             glyphHashUsed += fGlyphHash[i] ? sizeof(fGlyphHash[0]) : 0;
             uniHashUsed += fCharToGlyphHash[i].fID != 0xFFFFFFFF ? sizeof(fCharToGlyphHash[0]) : 0;
         }
         size_t glyphUsed = fGlyphArray.count() * sizeof(SkGlyph);
         size_t imageUsed = 0;
         for (int i = 0; i < fGlyphArray.count(); ++i) {
             const SkGlyph& g = *fGlyphArray[i];
             if (g.fImage) {
                 imageUsed += g.fHeight * g.rowBytes();
             }
         }
 
-        printf("glyphPtrArray,%zu, Alloc,%zu, imageUsed,%zu, glyphUsed,%zu, glyphHashAlloc,%zu, glyphHashUsed,%zu, unicharHashAlloc,%zu, unicharHashUsed,%zu\n",
-                 ptrMem, glyphAlloc, imageUsed, glyphUsed, sizeof(fGlyphHash), glyphHashUsed, sizeof(fCharToGlyphHash), uniHashUsed);
+        SkDebugf("glyphPtrArray,%zu, Alloc,%zu, imageUsed,%zu, glyphUsed,%zu, glyphHashAlloc,%zu, glyphHashUsed,%zu, unicharHashAlloc,%zu, unicharHashUsed,%zu\n",
+                 ptrMem, glyphAlloc, imageUsed, glyphUsed, sizeof(fGlyphHash), glyphHashUsed, sizeof(CharGlyphRec) * kHashCount, uniHashUsed);
 
     }
 #endif
     SkGlyph**   gptr = fGlyphArray.begin();
     SkGlyph**   stop = fGlyphArray.end();
     while (gptr < stop) {
         SkPath* path = (*gptr)->fPath;
         if (path) {
             SkDELETE(path);
         }
         gptr += 1;
     }
     SkDescriptor::Free(fDesc);
     SkDELETE(fScalerContext);
     this->invokeAndRemoveAuxProcs();
 }
 
+SkGlyphCache::CharGlyphRec* SkGlyphCache::getCharGlyphRec(uint32_t id) {
+    if (NULL == fCharToGlyphHash) {
+        fCharToGlyphHash.reset(new CharGlyphRec[kHashCount]);
+        // init with 0xFF so that the charCode field will be -1, which is invalid
+        memset(fCharToGlyphHash, 0xFF, sizeof(CharGlyphRec) * kHashCount);
+    }
+    
+    return &fCharToGlyphHash[ID2HashIndex(id)];
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 #define VALIDATE()  AutoValidate av(this)
 #else
 #define VALIDATE()
 #endif
 
 uint16_t SkGlyphCache::unicharToGlyph(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
-    const CharGlyphRec& rec = fCharToGlyphHash[ID2HashIndex(id)];
+    const CharGlyphRec& rec = *this->getCharGlyphRec(id);
 
     if (rec.fID == id) {
         return rec.fGlyph->getGlyphID();
     } else {
         return fScalerContext->charToGlyphID(charCode);
     }
 }
 
 SkUnichar SkGlyphCache::glyphToUnichar(uint16_t glyphID) {
     return fScalerContext->glyphIDToChar(glyphID);
 }
 
 unsigned SkGlyphCache::getGlyphCount() {
     return fScalerContext->getGlyphCount();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkGlyph& SkGlyphCache::getUnicharAdvance(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
-    CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
+    CharGlyphRec* rec = this->getCharGlyphRec(id);
 
     if (rec->fID != id) {
         // this ID is based on the UniChar
         rec->fID = id;
         // this ID is based on the glyph index
         id = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode));
         rec->fGlyph = this->lookupMetrics(id, kJustAdvance_MetricsType);
     }
     return *rec->fGlyph;
 }
 
 const SkGlyph& SkGlyphCache::getGlyphIDAdvance(uint16_t glyphID) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(glyphID);
     unsigned index = ID2HashIndex(id);
     SkGlyph* glyph = fGlyphHash[index];
 
     if (NULL == glyph || glyph->fID != id) {
         glyph = this->lookupMetrics(glyphID, kJustAdvance_MetricsType);
         fGlyphHash[index] = glyph;
     }
     return *glyph;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
-    CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
+    CharGlyphRec* rec = this->getCharGlyphRec(id);
 
     if (rec->fID != id) {
         RecordHashCollisionIf(rec->fGlyph != NULL);
         // this ID is based on the UniChar
         rec->fID = id;
         // this ID is based on the glyph index
         id = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode));
         rec->fGlyph = this->lookupMetrics(id, kFull_MetricsType);
     } else {
         RecordHashSuccess();
         if (rec->fGlyph->isJustAdvance()) {
             fScalerContext->getMetrics(rec->fGlyph);
         }
     }
     SkASSERT(rec->fGlyph->isFullMetrics());
     return *rec->fGlyph;
 }
 
 const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode,
                                                SkFixed x, SkFixed y) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode, x, y);
-    CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
+    CharGlyphRec* rec = this->getCharGlyphRec(id);
 
     if (rec->fID != id) {
         RecordHashCollisionIf(rec->fGlyph != NULL);
         // this ID is based on the UniChar
         rec->fID = id;
         // this ID is based on the glyph index
         id = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode), x, y);
         rec->fGlyph = this->lookupMetrics(id, kFull_MetricsType);
     } else {
         RecordHashSuccess();
@@ skipping 466 matching lines @@
     return tls ? tls->getCacheSizeLimit() : 0;
 }
 
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) {
     if (0 == bytes) {
         SkGlyphCache_Globals::DeleteTLS();
     } else {
         SkGlyphCache_Globals::GetTLS().setCacheSizeLimit(bytes);
     }
 }