expose instance methods on SkTypefaceCache

BUG=
R=bungeman@google.com

Review URL: https://codereview.chromium.org/23067003

git-svn-id: http://skia.googlecode.com/svn/trunk@10691 2bbb7eff-a529-9590-31e7-b0007b416f81

src/core/SkTypefaceCache.cpp

@@ -13,6 +13,21 @@
 
 #define TYPEFACE_CACHE_LIMIT    1024
 
+SkTypefaceCache::SkTypefaceCache() {}
+
+SkTypefaceCache::~SkTypefaceCache() {
+    const Rec* curr = fArray.begin();
+    const Rec* stop = fArray.end();
+    while (curr < stop) {
+        if (curr->fStrong) {
+            curr->fFace->unref();
+        } else {
+            curr->fFace->weak_unref();
+        }
+        curr += 1;
+    }
+}
+
 void SkTypefaceCache::add(SkTypeface* face,
                           SkTypeface::Style requestedStyle,
                           bool strong) {

src/core/SkTypefaceCache.h

@@ -23,6 +23,9 @@
 
 class SkTypefaceCache {
 public:
+    SkTypefaceCache();
+    ~SkTypefaceCache();
+
     /**
      * Callback for FindByProc. Returns true if the given typeface is a match
      * for the given context. The passed typeface is owned by the cache and is
@@ -30,21 +33,13 @@ public:
      */
     typedef bool (*FindProc)(SkTypeface*, SkTypeface::Style, void* context);
 
-    /**
-     *  Helper: returns a unique fontID to pass to the constructor of
-     *  your subclass of SkTypeface
-     */
-    static SkFontID NewFontID();
-
     /**
      *  Add a typeface to the cache. This ref()s the typeface, so that the
      *  cache is also an owner. Later, if we need to purge the cache, typefaces
      *  whose refcnt is 1 (meaning only the cache is an owner) will be
      *  unref()ed.
      */
-    static void Add(SkTypeface*,
-                    SkTypeface::Style requested,
-                    bool strong = true);
+    void add(SkTypeface*, SkTypeface::Style requested, bool strong = true);
 
     /**
      *  Search the cache for a typeface with the specified fontID (uniqueID).
@@ -52,14 +47,14 @@ public:
      *  is found, return NULL. The reference count is unmodified as it is
      *  assumed that the stack will contain a ref to the typeface.
      */
-    static SkTypeface* FindByID(SkFontID fontID);
+    SkTypeface* findByID(SkFontID findID) const;
 
     /**
      *  Iterate through the cache, calling proc(typeface, ctx) with each
      *  typeface. If proc returns true, then we return that typeface (this
      *  ref()s the typeface). If it never returns true, we return NULL.
      */
-    static SkTypeface* FindByProcAndRef(FindProc proc, void* ctx);
+    SkTypeface* findByProcAndRef(FindProc proc, void* ctx) const;
 
     /**
      *  This will unref all of the typefaces in the cache for which the cache
@@ -67,6 +62,21 @@ public:
      *  This function is exposed for clients that explicitly want to purge the
      *  cache (e.g. to look for leaks).
      */
+    void purgeAll();
+
+    /**
+     *  Helper: returns a unique fontID to pass to the constructor of
+     *  your subclass of SkTypeface
+     */
+    static SkFontID NewFontID();
+
+    // These are static wrappers around a global instance of a cache.
+
+    static void Add(SkTypeface*,
+                    SkTypeface::Style requested,
+                    bool strong = true);
+    static SkTypeface* FindByID(SkFontID fontID);
+    static SkTypeface* FindByProcAndRef(FindProc proc, void* ctx);
     static void PurgeAll();
 
     /**
@@ -77,11 +87,7 @@ public:
 private:
     static SkTypefaceCache& Get();
 
-    void add(SkTypeface*, SkTypeface::Style requested, bool strong = true);
-    SkTypeface* findByID(SkFontID findID) const;
-    SkTypeface* findByProcAndRef(FindProc proc, void* ctx) const;
     void purge(int count);
-    void purgeAll();
 
     struct Rec {
         SkTypeface*         fFace;