Remove SkThread.h, include SkMutex.h or SkAtomics.h as appropriate.

src/core/SkResourceCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
+#include "SkMutex.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 
 #include <stddef.h>
 
 DECLARE_SKMESSAGEBUS_MESSAGE(SkResourceCache::PurgeSharedIDMessage)
 
 // This can be defined by the caller's build system
 //#define SK_USE_DISCARDABLE_SCALEDIMAGECACHE
 
@@ skipping 46 matching lines @@
 
     // One of these should be explicit set by the caller after we return.
     fTotalByteLimit = 0;
     fDiscardableFactory = NULL;
 }
 
 #include "SkDiscardableMemory.h"
 
 class SkOneShotDiscardablePixelRef : public SkPixelRef {
 public:
-    
+
     // Ownership of the discardablememory is transfered to the pixelref
     SkOneShotDiscardablePixelRef(const SkImageInfo&, SkDiscardableMemory*, size_t rowBytes);
     ~SkOneShotDiscardablePixelRef();
 
 protected:
     bool onNewLockPixels(LockRec*) override;
     void onUnlockPixels() override;
     size_t getAllocatedSizeInBytes() const override;
 
 private:
@@ skipping 141 matching lines @@
         i += 1;
         size >>= 10;
     }
     str->printf("%zu%c", size, suffix[i]);
 }
 
 static bool gDumpCacheTransactions;
 
 void SkResourceCache::add(Rec* rec) {
     this->checkMessages();
-    
+
     SkASSERT(rec);
     // See if we already have this key (racy inserts, etc.)
     Rec* existing = fHash->find(rec->getKey());
     if (existing) {
         SkDELETE(rec);
         return;
     }
-    
+
     this->addToHead(rec);
     fHash->add(rec);
 
     if (gDumpCacheTransactions) {
         SkString bytesStr, totalStr;
         make_size_str(rec->bytesUsed(), &bytesStr);
         make_size_str(fTotalBytesUsed, &totalStr);
         SkDebugf("RC:    add %5s %12p key %08x -- total %5s, count %d\n",
                  bytesStr.c_str(), rec, rec->getHash(), totalStr.c_str(), fCount);
     }
@@ skipping 92 matching lines @@
     size_t prevLimit = fTotalByteLimit;
     fTotalByteLimit = newLimit;
     if (newLimit < prevLimit) {
         this->purgeAsNeeded();
     }
     return prevLimit;
 }
 
 SkCachedData* SkResourceCache::newCachedData(size_t bytes) {
     this->checkMessages();
-    
+
     if (fDiscardableFactory) {
         SkDiscardableMemory* dm = fDiscardableFactory(bytes);
         return dm ? SkNEW_ARGS(SkCachedData, (bytes, dm)) : NULL;
     } else {
         return SkNEW_ARGS(SkCachedData, (sk_malloc_throw(bytes), bytes));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 137 matching lines @@
 void SkResourceCache::checkMessages() {
     SkTArray<PurgeSharedIDMessage> msgs;
     fPurgeSharedIDInbox.poll(&msgs);
     for (int i = 0; i < msgs.count(); ++i) {
         this->purgeSharedID(msgs[i].fSharedID);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "SkThread.h"
-
 SK_DECLARE_STATIC_MUTEX(gMutex);
 static SkResourceCache* gResourceCache = NULL;
 static void cleanup_gResourceCache() {
     // We'll clean this up in our own tests, but disable for clients.
     // Chrome seems to have funky multi-process things going on in unit tests that
     // makes this unsafe to delete when the main process atexit()s.
     // SkLazyPtr does the same sort of thing.
 #if SK_DEVELOPER
     SkDELETE(gResourceCache);
 #endif
@@ skipping 108 matching lines @@
 
 size_t SkGraphics::SetResourceCacheSingleAllocationByteLimit(size_t newLimit) {
     return SkResourceCache::SetSingleAllocationByteLimit(newLimit);
 }
 
 void SkGraphics::PurgeResourceCache() {
     SkImageFilter::PurgeCache();
     return SkResourceCache::PurgeAll();
 }