Correct a possible free after use.

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 "SkGlyphCache_Globals.h"
 #include "SkGraphics.h"
@@ skipping 410 matching lines @@
         // pass true the first time, to notice if the scalercontext failed,
         // so we can try the purge.
         SkScalerContext* ctx = typeface->createScalerContext(desc, true);
         if (nullptr == ctx) {
             get_globals().purgeAll();
             ctx = typeface->createScalerContext(desc, false);
             SkASSERT(ctx);
         }
 
         cache = new SkGlyphCache(typeface, desc, ctx);
-
-        globals.attachCacheToHead(cache);
     }
 
-    AutoValidate av(cache);
     AutoAcquire ac(globals.fLock);

[mtklein, 2015/09/10 20:35:47]

Does this make sense?

// Do not lock globals.fLock here.
cache->fMapMutex.acquireShared();
if (!proc(cache, context)) {
   cache->fMapMutex.releaseShared();
   globals.attachCacheToHead(cache);
   return nullptr;
}
cache->fRefCount += 1;
globals.attachCacheToHead(cache);
return cache;

+    globals.internalAttachCacheToHead(cache);
 
     cache->fMapMutex.acquireShared();
     if (!proc(cache, context)) {   // need to reattach
         cache->fMapMutex.releaseShared();
         return nullptr;
     }
     // The caller will take reference on this SkGlyphCache, and the corresponding
     // Attach call will decrement the reference.
     cache->fRefCount += 1;
     return cache;
@@ skipping 80 matching lines @@
 
     globals.validate();
 
     for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
         visitor(*cache, context);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
-    AutoAcquire ac(fLock);
-
+void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
+    this->internalPurge();
     fCacheCount += 1;
     cache->fRefCount += 1;
     // Access to cache->fMemoryUsed is single threaded until internalMoveToHead.
     fTotalMemoryUsed.fetch_add(cache->fMemoryUsed);
 
     this->internalMoveToHead(cache);
 
     this->validate();
     cache->validate();
-
-    this->internalPurge();
 }
 
 SkGlyphCache* SkGlyphCache_Globals::internalGetTail() const {
     SkGlyphCache* cache = fHead;
     if (cache) {
         while (cache->fNext) {
             cache = cache->fNext;
         }
     }
     return cache;
@@ skipping 160 matching lines @@
 }
 
 void SkGraphics::PurgeFontCache() {
     get_globals().purgeAll();
     SkTypefaceCache::PurgeAll();
 }
 
 // TODO(herb): clean up TLS apis.
 size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }