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

src/core/SkCachedData.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCachedData_DEFINED
 #define SkCachedData_DEFINED
 
-#include "SkThread.h"
+#include "SkMutex.h"
 
 class SkDiscardableMemory;
 
 class SkCachedData : ::SkNoncopyable {
 public:
     SkCachedData(void* mallocData, size_t size);
     SkCachedData(size_t size, SkDiscardableMemory*);
     virtual ~SkCachedData();
 
     size_t size() const { return fSize; }
@@ skipping 49 matching lines @@
     }
 
     class AutoMutexWritable;
 
 public:
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
-    
+
    /*
      *  Attaching a data to to a SkResourceCache (only one at a time) enables the data to be
      *  unlocked when the cache is the only owner, thus freeing it to be purged (assuming the
      *  data is backed by a SkDiscardableMemory).
      *
      *  When attached, it also automatically attempts to "lock" the data when the first client
      *  ref's the data (typically from a find(key, visitor) call).
      *
      *  Thus the data will always be "locked" when a non-cache has a ref on it (whether or not
      *  the lock succeeded to recover the memory -- check data() to see if it is NULL).
      */
 
     /*
      *  Call when adding this instance to a SkResourceCache::Rec subclass
      *  (typically in the Rec's constructor).
      */
     void attachToCacheAndRef() const { this->internalRef(true); }
 
     /*
      *  Call when removing this instance from a SkResourceCache::Rec subclass
      *  (typically in the Rec's destructor).
      */
     void detachFromCacheAndUnref() const { this->internalUnref(true); }
 };
 
 #endif