Every pixel ref gets its own mutex.

src/core/SkPixelRef.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkMutex.h"
 #include "SkPixelRef.h"
 #include "SkTraceEvent.h"
 
 //#define SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT
 //#define SK_TRACE_PIXELREF_LIFETIME
 
-#ifdef SK_BUILD_FOR_WIN32
-    // We don't have SK_BASE_MUTEX_INIT on Windows.
-
-    // must be a power-of-2. undef to just use 1 mutex
-    #define PIXELREF_MUTEX_RING_COUNT       32
-    static SkBaseMutex gPixelRefMutexRing[PIXELREF_MUTEX_RING_COUNT];
-
-#else
-    static SkBaseMutex gPixelRefMutexRing[] = {
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-        SK_BASE_MUTEX_INIT, SK_BASE_MUTEX_INIT,
-    };
-    // must be a power-of-2. undef to just use 1 mutex
-    #define PIXELREF_MUTEX_RING_COUNT SK_ARRAY_COUNT(gPixelRefMutexRing)
-
-#endif
-
-static SkBaseMutex* get_default_mutex() {
-    static int32_t gPixelRefMutexRingIndex;
-
-    SkASSERT(SkIsPow2(PIXELREF_MUTEX_RING_COUNT));
-
-    // atomic_inc might be overkill here. It may be fine if once in a while
-    // we hit a race-condition and two subsequent calls get the same index...
-    int index = sk_atomic_inc(&gPixelRefMutexRingIndex);
-    return &gPixelRefMutexRing[index & (PIXELREF_MUTEX_RING_COUNT - 1)];
-}
-
-///////////////////////////////////////////////////////////////////////////////
 #include "SkNextID.h"
 
 uint32_t SkNextID::ImageID() {
     static uint32_t gID = 0;
     uint32_t id;
     // Loop in case our global wraps around, as we never want to return a 0.
     do {
         id = sk_atomic_fetch_add(&gID, 2u) + 2;  // Never set the low bit.
     } while (0 == id);
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPixelRef::setMutex(SkBaseMutex* mutex) {
-    if (NULL == mutex) {
-        mutex = get_default_mutex();
-    }
-    fMutex = mutex;
-}
-
 // just need a > 0 value, so pick a funny one to aid in debugging
 #define SKPIXELREF_PRELOCKED_LOCKCOUNT     123456789
 
 static SkImageInfo validate_info(const SkImageInfo& info) {
     SkAlphaType newAlphaType = info.alphaType();
     SkAssertResult(SkColorTypeValidateAlphaType(info.colorType(), info.alphaType(), &newAlphaType));
     return info.makeAlphaType(newAlphaType);
 }
 
 #ifdef SK_TRACE_PIXELREF_LIFETIME
     static int32_t gInstCounter;
 #endif
 
 SkPixelRef::SkPixelRef(const SkImageInfo& info)
     : fInfo(validate_info(info))
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     , fStableID(SkNextID::ImageID())
 #endif
 
 {
 #ifdef SK_TRACE_PIXELREF_LIFETIME
     SkDebugf(" pixelref %d\n", sk_atomic_inc(&gInstCounter));
 #endif
-    this->setMutex(NULL);
     fRec.zero();
     fLockCount = 0;
     this->needsNewGenID();
-    fMutability = kMutable;
-    fPreLocked = false;
-    fAddedToCache.store(false);
-}
-
-
-SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex)
-    : fInfo(validate_info(info))
-#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-    , fStableID(SkNextID::ImageID())
-#endif
-{
-#ifdef SK_TRACE_PIXELREF_LIFETIME
-    SkDebugf(" pixelref %d\n", sk_atomic_inc(&gInstCounter));
-#endif
-    this->setMutex(mutex);
-    fRec.zero();
-    fLockCount = 0;
-    this->needsNewGenID();
     fMutability = kMutable;
     fPreLocked = false;
     fAddedToCache.store(false);
 }
 
 SkPixelRef::~SkPixelRef() {
 #ifndef SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT
     SkASSERT(SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount || 0 == fLockCount);
 #endif
 
@@ skipping 40 matching lines @@
     // out of sync.
     fRec.fPixels = pixels;
     fRec.fColorTable = ctable;
     fRec.fRowBytes = rowBytes;
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
     fPreLocked = true;
 }
 
 // Increments fLockCount only on success
 bool SkPixelRef::lockPixelsInsideMutex() {
-    fMutex->assertHeld();
+    fMutex.assertHeld();
 
     if (1 == ++fLockCount) {
         SkASSERT(fRec.isZero());
         if (!this->onNewLockPixels(&fRec)) {
             fRec.zero();
             fLockCount -= 1;    // we return fLockCount unchanged if we fail.
             return false;
         }
     }
     if (fRec.fPixels) {
         validate_pixels_ctable(fInfo, fRec.fColorTable);
         return true;
     }
     // no pixels, so we failed (somehow)
     --fLockCount;
     return false;
 }
 
 // For historical reasons, we always inc fLockCount, even if we return false.
 // It would be nice to change this (it seems), and only inc if we actually succeed...
 bool SkPixelRef::lockPixels() {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
         TRACE_EVENT_BEGIN0("skia", "SkPixelRef::lockPixelsMutex");
-        SkAutoMutexAcquire  ac(*fMutex);
+        SkAutoMutexAcquire  ac(fMutex);
         TRACE_EVENT_END0("skia", "SkPixelRef::lockPixelsMutex");
         SkDEBUGCODE(int oldCount = fLockCount;)
         bool success = this->lockPixelsInsideMutex();
         // lockPixelsInsideMutex only increments the count if it succeeds.
         SkASSERT(oldCount + (int)success == fLockCount);
 
         if (!success) {
             // For compatibility with SkBitmap calling lockPixels, we still want to increment
             // fLockCount even if we failed. If we updated SkBitmap we could remove this oddity.
             fLockCount += 1;
@@ skipping 12 matching lines @@
         *rec = fRec;
         return true;
     }
     return false;
 }
 
 void SkPixelRef::unlockPixels() {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
-        SkAutoMutexAcquire  ac(*fMutex);
+        SkAutoMutexAcquire  ac(fMutex);
 
         SkASSERT(fLockCount > 0);
         if (0 == --fLockCount) {
             // don't call onUnlockPixels unless onLockPixels succeeded
             if (fRec.fPixels) {
                 this->onUnlockPixels();
                 fRec.zero();
             } else {
                 SkASSERT(fRec.isZero());
             }
@@ skipping 12 matching lines @@
     }
 
     if (fPreLocked) {
         result->fUnlockProc = NULL;
         result->fUnlockContext = NULL;
         result->fCTable = fRec.fColorTable;
         result->fPixels = fRec.fPixels;
         result->fRowBytes = fRec.fRowBytes;
         result->fSize.set(fInfo.width(), fInfo.height());
     } else {
-        SkAutoMutexAcquire  ac(*fMutex);
+        SkAutoMutexAcquire  ac(fMutex);
         if (!this->onRequestLock(request, result)) {
             return false;
         }
     }
     if (result->fPixels) {
         validate_pixels_ctable(fInfo, result->fCTable);
         return true;
     }
     return false;
 }
@@ skipping 125 matching lines @@
     }
 
     result->fUnlockProc = unlock_legacy_result;
     result->fUnlockContext = SkRef(this);   // this is balanced in our fUnlockProc
     result->fCTable = fRec.fColorTable;
     result->fPixels = fRec.fPixels;
     result->fRowBytes = fRec.fRowBytes;
     result->fSize.set(fInfo.width(), fInfo.height());
     return true;
 }