Use SkAutoTExclusive.

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 275 matching lines @@
         rec->fProc(rec->fData);
         AuxProcRec* next = rec->fNext;
         delete rec;
         rec = next;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-
-class AutoAcquire {
-public:
-    AutoAcquire(SkSpinlock& lock) : fLock(lock) { fLock.acquire(); }
-    ~AutoAcquire() { fLock.release(); }
-private:
-    SkSpinlock& fLock;
-};
+typedef SkAutoTExclusive<SkSpinlock> Exclusive;
 
 size_t SkGlyphCache_Globals::setCacheSizeLimit(size_t newLimit) {
     static const size_t minLimit = 256 * 1024;
     if (newLimit < minLimit) {
         newLimit = minLimit;
     }
 
-    AutoAcquire ac(fLock);
+    Exclusive ac(fLock);
 
     size_t prevLimit = fCacheSizeLimit;
     fCacheSizeLimit = newLimit;
     this->internalPurge();
     return prevLimit;
 }
 
 int SkGlyphCache_Globals::setCacheCountLimit(int newCount) {
     if (newCount < 0) {
         newCount = 0;
     }
 
-    AutoAcquire ac(fLock);
+    Exclusive ac(fLock);
 
     int prevCount = fCacheCountLimit;
     fCacheCountLimit = newCount;
     this->internalPurge();
     return prevCount;
 }
 
 void SkGlyphCache_Globals::purgeAll() {
-    AutoAcquire ac(fLock);
+    Exclusive ac(fLock);
     this->internalPurge(fTotalMemoryUsed);
 }
 
 /*  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(SkTypeface* typeface,
                               const SkDescriptor* desc,
                               bool (*proc)(const SkGlyphCache*, void*),
                               void* context) {
     if (!typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
     SkASSERT(desc);
 
     SkGlyphCache_Globals& globals = get_globals();
     SkGlyphCache*         cache;
 
     {
-        AutoAcquire ac(globals.fLock);
+        Exclusive ac(globals.fLock);
 
         globals.validate();
 
         for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
             if (cache->fDesc->equals(*desc)) {
                 globals.internalDetachCache(cache);
                 if (!proc(cache, context)) {
                     globals.internalAttachCacheToHead(cache);
                     cache = nullptr;
                 }
@@ skipping 92 matching lines @@
     if (dump->getRequestedDetails() == SkTraceMemoryDump::kLight_LevelOfDetail) {
         dump->setMemoryBacking(gGlyphCacheDumpName, "malloc", nullptr);
         return;
     }
 
     SkGlyphCache::VisitAll(sk_trace_dump_visitor, dump);
 }
 
 void SkGlyphCache::VisitAll(Visitor visitor, void* context) {
     SkGlyphCache_Globals& globals = get_globals();
-    AutoAcquire           ac(globals.fLock);
+    Exclusive ac(globals.fLock);
     SkGlyphCache*         cache;
 
     globals.validate();
 
     for (cache = globals.internalGetHead(); cache != nullptr; cache = cache->fNext) {
         visitor(*cache, context);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
-    AutoAcquire ac(fLock);
+    Exclusive ac(fLock);
 
     this->validate();
     cache->validate();
 
     this->internalAttachCacheToHead(cache);
     this->internalPurge();
 }
 
 SkGlyphCache* SkGlyphCache_Globals::internalGetTail() const {
     SkGlyphCache* cache = fHead;
@@ skipping 153 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) { }