Add SkTypeface* parameter to SkScalerContext (and its callers)

trunk/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"
 #include "SkGraphics.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkTemplates.h"
 #include "SkTLS.h"
+#include "SkTypeface.h"
 
 //#define SPEW_PURGE_STATUS
 //#define USE_CACHE_HASH
 //#define RECORD_HASH_EFFICIENCY
 
 bool gSkSuppressFontCachePurgeSpew;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef RECORD_HASH_EFFICIENCY
@@ skipping 19 matching lines @@
 #endif
 #define RecordHashCollision() RecordHashCollisionIf(true)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define kMinGlphAlloc       (sizeof(SkGlyph) * 64)
 #define kMinImageAlloc      (24 * 64)   // should be pointsize-dependent
 
 #define METRICS_RESERVE_COUNT  128  // so we don't grow this array a lot
 
-SkGlyphCache::SkGlyphCache(const SkDescriptor* desc)
-        : fGlyphAlloc(kMinGlphAlloc), fImageAlloc(kMinImageAlloc) {
+SkGlyphCache::SkGlyphCache(SkTypeface* typeface, const SkDescriptor* desc)
+        : fGlyphAlloc(kMinGlphAlloc)
+        , fImageAlloc(kMinImageAlloc) {
+    SkASSERT(typeface);
+
     fPrev = fNext = NULL;
 
     fDesc = desc->copy();
-    fScalerContext = SkScalerContext::Create(desc);
+    fScalerContext = typeface->createScalerContext(desc);
     fScalerContext->getFontMetrics(NULL, &fFontMetricsY);
 
     // 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) + kMinGlphAlloc + kMinImageAlloc;
 
     fGlyphArray.setReserve(METRICS_RESERVE_COUNT);
@@ skipping 445 matching lines @@
 
     globals.validate();
 }
 
 /*  This guy calls the visitor from within the mutext lock, so the visitor
     cannot:
     - take too much time
     - try to acquire the mutext again
     - call a fontscaler (which might call into the cache)
 */
-SkGlyphCache* SkGlyphCache::VisitCache(const SkDescriptor* desc,
+SkGlyphCache* SkGlyphCache::VisitCache(SkTypeface* typeface,
+                              const SkDescriptor* desc,
                               bool (*proc)(const SkGlyphCache*, void*),
                               void* context) {
+    if (!typeface) {
+        typeface = SkTypeface::GetDefaultTypeface();
+    }
     SkASSERT(desc);
 
     SkGlyphCache_Globals& globals = getGlobals();
     SkAutoMutexAcquire    ac(globals.fMutex);
     SkGlyphCache*         cache;
     bool                  insideMutex = true;
 
     globals.validate();
 
 #ifdef USE_CACHE_HASH
@@ skipping 12 matching lines @@
             goto FOUND_IT;
         }
     }
 
     /* Release the mutex now, before we create a new entry (which might have
         side-effects like trying to access the cache/mutex (yikes!)
     */
     ac.release();           // release the mutex now
     insideMutex = false;    // can't use globals anymore
 
-    cache = SkNEW_ARGS(SkGlyphCache, (desc));
+    cache = SkNEW_ARGS(SkGlyphCache, (typeface, desc));
 
 FOUND_IT:
 
     AutoValidate av(cache);
 
     if (proc(cache, context)) {   // stay detached
         if (insideMutex) {
             SkASSERT(globals.fTotalMemoryUsed >= cache->fMemoryUsed);
             globals.fTotalMemoryUsed -= cache->fMemoryUsed;
 #ifdef USE_CACHE_HASH
@@ skipping 162 matching lines @@
     return tls ? tls->getFontCacheLimit() : 0;
 }
 
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) {
     if (0 == bytes) {
         SkGlyphCache_Globals::DeleteTLS();
     } else {
         SkGlyphCache_Globals::GetTLS().setFontCacheLimit(bytes);
     }
 }