Add SkTypeface* parameter to SkScalerContext (and its callers)

trunk/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
@@ skipping 117 matching lines @@
     /** Call proc on all cache entries, stopping early if proc returns true.
         The proc should not create or delete caches, since it could produce
         deadlock.
     */
     static void VisitAllCaches(bool (*proc)(SkGlyphCache*, void*), void* ctx);
 
     /** Find a matching cache entry, and call proc() with it. If none is found
         create a new one. If the proc() returns true, detach the cache and
         return it, otherwise leave it and return NULL.
     */
-    static SkGlyphCache* VisitCache(const SkDescriptor* desc,
+    static SkGlyphCache* VisitCache(SkTypeface*, const SkDescriptor* desc,
                                     bool (*proc)(const SkGlyphCache*, void*),
                                     void* context);
 
     /** Given a strike that was returned by either VisitCache() or DetachCache()
         add it back into the global cache list (after which the caller should
         not reference it anymore.
     */
     static void AttachCache(SkGlyphCache*);
 
     /** Detach a strike from the global cache matching the specified descriptor.
         Once detached, it can be queried/modified by the current thread, and
         when finished, be reattached to the global cache with AttachCache().
         While detached, if another request is made with the same descriptor,
         a different strike will be generated. This is fine. It does mean we
         can have more than 1 strike for the same descriptor, but that will
         eventually get purged, and the win is that different thread will never
         block each other while a strike is being used.
     */
-    static SkGlyphCache* DetachCache(const SkDescriptor* desc) {
-        return VisitCache(desc, DetachProc, NULL);
+    static SkGlyphCache* DetachCache(SkTypeface* typeface,
+                                     const SkDescriptor* desc) {
+        return VisitCache(typeface, desc, DetachProc, NULL);
     }
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     class AutoValidate : SkNoncopyable {
     public:
         AutoValidate(const SkGlyphCache* cache) : fCache(cache) {
             if (fCache) {
                 fCache->validate();
             }
         }
         ~AutoValidate() {
             if (fCache) {
                 fCache->validate();
             }
         }
         void forget() {
             fCache = NULL;
         }
     private:
         const SkGlyphCache* fCache;
     };
 
 private:
-    SkGlyphCache(const SkDescriptor*);
+    SkGlyphCache(SkTypeface*, const SkDescriptor*);
     ~SkGlyphCache();
 
     enum MetricsType {
         kJustAdvance_MetricsType,
         kFull_MetricsType
     };
 
     SkGlyph* lookupMetrics(uint32_t id, MetricsType);
     static bool DetachProc(const SkGlyphCache*, void*) { return true; }
 
@@ skipping 68 matching lines @@
     static size_t InternalFreeCache(SkGlyphCache_Globals*, size_t bytesNeeded);
 
     inline static SkGlyphCache* FindTail(SkGlyphCache* head);
 
     friend class SkGlyphCache_Globals;
 };
 
 class SkAutoGlyphCache {
 public:
     SkAutoGlyphCache(SkGlyphCache* cache) : fCache(cache) {}
-    SkAutoGlyphCache(const SkDescriptor* desc) {
-        fCache = SkGlyphCache::DetachCache(desc);
+    SkAutoGlyphCache(SkTypeface* typeface, const SkDescriptor* desc) {
+        fCache = SkGlyphCache::DetachCache(typeface, desc);
     }
     SkAutoGlyphCache(const SkPaint& paint,
                      const SkDeviceProperties* deviceProperties,
                      const SkMatrix* matrix) {
         fCache = paint.detachCache(deviceProperties, matrix);
     }
     ~SkAutoGlyphCache() {
         if (fCache) {
             SkGlyphCache::AttachCache(fCache);
         }
     }
 
     SkGlyphCache* getCache() const { return fCache; }
 
     void release() {
         if (fCache) {
             SkGlyphCache::AttachCache(fCache);
             fCache = NULL;
         }
     }
 
 private:
     SkGlyphCache*   fCache;
 
     static bool DetachProc(const SkGlyphCache*, void*);
 };
 
 #endif