Add asserts for shared mutex.

src/core/SkSharedMutex.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSharedMutex.h"
 
 #include "SkAtomics.h"
@@ skipping 123 matching lines @@
 
     if (waitingShared > 0) {
         // Run all the shared.
         fSharedQueue.signal(waitingShared);
     } else if ((newQueueCounts & kWaitingExclusiveMask) > 0) {
         // Run a single exclusive waiter.
         fExclusiveQueue.signal();
     }
 }
 
+
+void SkSharedMutex::assertHeld() const {
+    int32_t queueCounts = fQueueCounts.load(sk_memory_order_relaxed);
+    // These are very loose asserts about the mutex being held exclusively.
+    SkASSERTF(0 == (queueCounts & kSharedMask),
+              "running shared: %d, exclusive: %d, waiting shared: %d",
+              (queueCounts & kSharedMask) >> kSharedOffset,
+              (queueCounts & kWaitingExclusiveMask) >> kWaitingExlusiveOffset,
+              (queueCounts & kWaitingSharedMask) >> kWaitingSharedOffset);
+    SkASSERTF((queueCounts & kWaitingExclusiveMask) > 0,
+              "running shared: %d, exclusive: %d, waiting shared: %d",
+              (queueCounts & kSharedMask) >> kSharedOffset,
+              (queueCounts & kWaitingExclusiveMask) >> kWaitingExlusiveOffset,
+              (queueCounts & kWaitingSharedMask) >> kWaitingSharedOffset);
+}
+
 void SkSharedMutex::acquireShared() {
     int32_t oldQueueCounts = fQueueCounts.load(sk_memory_order_relaxed);
     int32_t newQueueCounts;
     do {
         newQueueCounts = oldQueueCounts;
         // If there are waiting exclusives then this shared lock waits else it runs.
         if ((newQueueCounts & kWaitingExclusiveMask) > 0) {
             newQueueCounts += 1 << kWaitingSharedOffset;
         } else {
             newQueueCounts += 1 << kSharedOffset;
@@ skipping 16 matching lines @@
     int32_t oldQueueCounts = fQueueCounts.fetch_add(~0U << kSharedOffset,
                                                     sk_memory_order_release);
 
     // If shared count is going to zero (because the old count == 1) and there are exclusive
     // waiters, then run a single exclusive waiter.
     if (((oldQueueCounts & kSharedMask) >> kSharedOffset) == 1
         && (oldQueueCounts & kWaitingExclusiveMask) > 0) {
         fExclusiveQueue.signal();
     }
 }
+
+void SkSharedMutex::assertHeldShared() const {
+    int32_t queueCounts = fQueueCounts.load(sk_memory_order_relaxed);
+    // A very loose assert about the mutex being shared.
+    SkASSERTF((queueCounts & kSharedMask) > 0,
+              "running shared: %d, exclusive: %d, waiting shared: %d",
+              (queueCounts & kSharedMask) >> kSharedOffset,
+              (queueCounts & kWaitingExclusiveMask) >> kWaitingExlusiveOffset,
+              (queueCounts & kWaitingSharedMask) >> kWaitingSharedOffset);
+}