Every pixel ref gets its own mutex.

include/core/SkPixelRef.h

 /*
  * Copyright 2008 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.
  */
 
 #ifndef SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
@@ skipping 18 matching lines @@
 
     This class is the smart container for pixel memory, and is used with
     SkBitmap. A pixelref is installed into a bitmap, and then the bitmap can
     access the actual pixel memory by calling lockPixels/unlockPixels.
 
     This class can be shared/accessed between multiple threads.
 */
 class SK_API SkPixelRef : public SkRefCnt {
 public:
     explicit SkPixelRef(const SkImageInfo&);
-    SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex);
     virtual ~SkPixelRef();
 
     const SkImageInfo& info() const {
         return fInfo;
     }
 
     /** Return the pixel memory returned from lockPixels, or null if the
         lockCount is 0.
     */
     void* pixels() const { return fRec.fPixels; }
@@ skipping 262 matching lines @@
      *
      *  @return default impl returns 0.
      */
     virtual size_t getAllocatedSizeInBytes() const;
 
     virtual bool onRequestLock(const LockRequest&, LockResult*);
 
     /** Return the mutex associated with this pixelref. This value is assigned
         in the constructor, and cannot change during the lifetime of the object.
     */
-    SkBaseMutex* mutex() const { return fMutex; }
+    SkBaseMutex* mutex() const { return &fMutex; }
 
     // only call from constructor. Flags this to always be locked, removing
     // the need to grab the mutex and call onLockPixels/onUnlockPixels.
     // Performance tweak to avoid those calls (esp. in multi-thread use case).
     void setPreLocked(void*, size_t rowBytes, SkColorTable*);
 
 private:
-    SkBaseMutex*    fMutex; // must remain in scope for the life of this object
+    mutable SkMutex fMutex;
 
     // mostly const. fInfo.fAlpahType can be changed at runtime.
     const SkImageInfo fInfo;
 
     // LockRec is only valid if we're in a locked state (isLocked())
     LockRec         fRec;
     int             fLockCount;
 
     bool lockPixelsInsideMutex();
 
@@ skipping 17 matching lines @@
         kTemporarilyImmutable,  // Considered immutable, but can revert to mutable.
         kImmutable,             // Once set to this state, it never leaves.
     } fMutability : 8;          // easily fits inside a byte
 
     // only ever set in constructor, const after that
     bool fPreLocked;
 
     void needsNewGenID();
     void callGenIDChangeListeners();
 
-    void setMutex(SkBaseMutex* mutex);
-
     void setTemporarilyImmutable();
     void restoreMutability();
     friend class SkSurface_Raster;   // For the two methods above.
 
     bool isPreLocked() const { return fPreLocked; }
     friend class SkImage_Raster;
 
     // When copying a bitmap to another with the same shape and config, we can safely
     // clone the pixelref generation ID too, which makes them equivalent under caching.
     friend class SkBitmap;  // only for cloneGenID
@@ skipping 10 matching lines @@
     /**
      *  Allocate a new pixelref matching the specified ImageInfo, allocating
      *  the memory for the pixels. If the ImageInfo requires a ColorTable,
      *  the pixelref will ref() the colortable.
      *  On failure return NULL.
      */
     virtual SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) = 0;
 };
 
 #endif