Revert of Modernize SkMutex and SkSemaphore.

src/lazy/SkDiscardableMemoryPool.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 "SkDiscardableMemory.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkImageGenerator.h"
@@ skipping 11 matching lines @@
 
 /**
  *  This non-global pool can be used for unit tests to verify that the
  *  pool works.
  */
 class DiscardableMemoryPool : public SkDiscardableMemoryPool {
 public:
     /**
      *  Without mutex, will be not be thread safe.
      */
-    DiscardableMemoryPool(size_t budget, SkMutex* mutex = nullptr);
+    DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = nullptr);
     virtual ~DiscardableMemoryPool();
 
     SkDiscardableMemory* create(size_t bytes) override;
 
     size_t getRAMUsed() override;
     void setRAMBudget(size_t budget) override;
     size_t getRAMBudget() override { return fBudget; }
 
     /** purges all unlocked DMs */
     void dumpPool() override;
 
     #if SK_LAZY_CACHE_STATS  // Defined in SkDiscardableMemoryPool.h
     int getCacheHits() override { return fCacheHits; }
     int getCacheMisses() override { return fCacheMisses; }
     void resetCacheHitsAndMisses() override {
         fCacheHits = fCacheMisses = 0;
     }
     int          fCacheHits;
     int          fCacheMisses;
     #endif  // SK_LAZY_CACHE_STATS
 
 private:
-    SkMutex* fMutex;
-    size_t   fBudget;
-    size_t   fUsed;
+    SkBaseMutex* fMutex;
+    size_t       fBudget;
+    size_t       fUsed;
     SkTInternalLList<PoolDiscardableMemory> fList;
 
     /** Function called to free memory if needed */
     void dumpDownTo(size_t budget);
     /** called by DiscardableMemoryPool upon destruction */
     void free(PoolDiscardableMemory* dm);
     /** called by DiscardableMemoryPool::lock() */
     bool lock(PoolDiscardableMemory* dm);
     /** called by DiscardableMemoryPool::unlock() */
     void unlock(PoolDiscardableMemory* dm);
@@ skipping 53 matching lines @@
     return fPointer;
 }
 
 void PoolDiscardableMemory::unlock() {
     SkASSERT(fLocked); // contract for SkDiscardableMemory
     fPool->unlock(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-DiscardableMemoryPool::DiscardableMemoryPool(size_t budget, SkMutex* mutex)
+DiscardableMemoryPool::DiscardableMemoryPool(size_t budget,
+                                             SkBaseMutex* mutex)
     : fMutex(mutex)
     , fBudget(budget)
     , fUsed(0) {
     #if SK_LAZY_CACHE_STATS
     fCacheHits = 0;
     fCacheMisses = 0;
     #endif  // SK_LAZY_CACHE_STATS
 }
 DiscardableMemoryPool::~DiscardableMemoryPool() {
     // PoolDiscardableMemory objects that belong to this pool are
@@ skipping 91 matching lines @@
     fBudget = budget;
     this->dumpDownTo(fBudget);
 }
 void DiscardableMemoryPool::dumpPool() {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     this->dumpDownTo(0);
 }
 
 }  // namespace
 
-SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create(size_t size, SkMutex* mutex) {
+SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create(size_t size, SkBaseMutex* mutex) {
     return new DiscardableMemoryPool(size, mutex);
 }
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
 SK_DECLARE_STATIC_ONCE_PTR(SkDiscardableMemoryPool, global);
 
 SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() {
     return global.get([] {
         return SkDiscardableMemoryPool::Create(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE,
                                                &gMutex);
     });
 }