Add guards around access to font cache global fields.

src/core/SkGlyphCache_Globals.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGlyphCache_Globals_DEFINED
 #define SkGlyphCache_Globals_DEFINED
 
@@ skipping 24 matching lines @@
 
     ~SkGlyphCache_Globals() {
         SkGlyphCache* cache = fHead;
         while (cache) {
             SkGlyphCache* next = cache->fNext;
             delete cache;
             cache = next;
         }
     }
 
-    SkSpinlock     fLock;
+    mutable SkSpinlock     fLock;

[reed1, 2016/06/22 16:05:36]

make private?

 
     SkGlyphCache* internalGetHead() const { return fHead; }
     SkGlyphCache* internalGetTail() const;
 
-    size_t getTotalMemoryUsed() const { return fTotalMemoryUsed; }
-    int getCacheCountUsed() const { return fCacheCount; }
+    size_t getTotalMemoryUsed() const;
+    int getCacheCountUsed() const;
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
-    int getCacheCountLimit() const { return fCacheCountLimit; }
+    int getCacheCountLimit() const;
     int setCacheCountLimit(int limit);
 
-    size_t  getCacheSizeLimit() const { return fCacheSizeLimit; }
+    size_t  getCacheSizeLimit() const;
     size_t  setCacheSizeLimit(size_t limit);
 
-    // returns true if this cache is over-budget either due to size limit
-    // or count limit.
-    bool isOverBudget() const {
-        return fCacheCount > fCacheCountLimit ||
-               fTotalMemoryUsed > fCacheSizeLimit;
-    }
-
     void purgeAll(); // does not change budget
 
     // call when a glyphcache is available for caching (i.e. not in use)
     void attachCacheToHead(SkGlyphCache*);
 
     // can only be called when the mutex is already held
     void internalDetachCache(SkGlyphCache*);
     void internalAttachCacheToHead(SkGlyphCache*);
 
 private:
     SkGlyphCache* fHead;
     size_t  fTotalMemoryUsed;
     size_t  fCacheSizeLimit;
     int32_t fCacheCountLimit;
     int32_t fCacheCount;
 
     // Checkout budgets, modulated by the specified min-bytes-needed-to-purge,
     // and attempt to purge caches to match.
     // Returns number of bytes freed.
     size_t internalPurge(size_t minBytesNeeded = 0);
 };
 
 #endif