Use a spinlock in SkOnce.

include/core/SkThread.h

 /*
  * Copyright 2006 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 SkThread_DEFINED
 #define SkThread_DEFINED
 
@@ skipping 15 matching lines @@
  *  This must act as a release (SL/S) memory barrier and as a compiler barrier.
  */
 static int32_t sk_atomic_dec(int32_t* addr);
 
 /** Atomically adds one to the int referenced by addr iff the referenced int was not 0
  *  and returns the previous value.
  *  No additional memory barrier is required; this must act as a compiler barrier.
  */
 static int32_t sk_atomic_conditional_inc(int32_t* addr);
 
+/** Atomic compare and set.
+ *  If *addr == before, set *addr to after and return true, otherwise return false.
+ *  This must act as a release (SL/S) memory barrier and as a compiler barrier.
+ */
+static bool sk_atomic_cas(int32_t* addr, int32_t before, int32_t after);
+
 /** If sk_atomic_dec does not act as an acquire (L/SL) barrier,
  *  this must act as an acquire (L/SL) memory barrier and as a compiler barrier.
  */
 static void sk_membar_acquire__after_atomic_dec();
 
 /** If sk_atomic_conditional_inc does not act as an acquire (L/SL) barrier,
  *  this must act as an acquire (L/SL) memory barrier and as a compiler barrier.
  */
 static void sk_membar_acquire__after_atomic_conditional_inc();
 
 #include SK_ATOMICS_PLATFORM_H
 
+// This is POD and must be zero-initialized.
+struct SkSpinlock {
+    void acquire() {
+        SkASSERT(shouldBeZero == 0);
+        while (!sk_atomic_cas(&thisIsPrivate, 0, 1)) {

[bungeman-skia, 2014/01/08 18:35:44]

I'd still like a comment here that this doesn't require a memory barrier.

+            // spin
+        }
+    }
+
+    void release() {
+        SkASSERT(shouldBeZero == 0);
+        SkAssertResult(sk_atomic_cas(&thisIsPrivate, 1, 0));

[bungeman-skia, 2014/01/08 18:35:44]

I'd still like a comment here that this requires a release memory barrier.

This is mostly to explicitly document the spinlock algorithm, so that if we end
up changing _cas (to have _none, _release, _acquire, or whatever) we don't lose
this otherwise implicit information which is easy to overlook. This request is
mostly due to frustration I've had looking at other code which did not document
the barriers required.

+    }
+
+    int32_t thisIsPrivate;
+    SkDEBUGCODE(int32_t shouldBeZero;)
+};
+
+class SkAutoSpinlock : SkNoncopyable {
+public:
+    explicit SkAutoSpinlock(SkSpinlock* lock) : fLock(lock) { fLock->acquire(); }
+    ~SkAutoSpinlock() { fLock->release(); }
+private:
+    SkSpinlock* fLock;
+};
+#define SkAutoSpinlock(...) SK_REQUIRE_LOCAL_VAR(SkAutoSpinlock)
 
 /** SK_MUTEX_PLATFORM_H must provide the following (or equivalent) declarations.
 
 class SkBaseMutex {
 public:
     void acquire();
     void release();
 };
 
 class SkMutex : SkBaseMutex {
@@ skipping 36 matching lines @@
             fMutex = NULL;
         }
     }
 
 private:
     SkBaseMutex* fMutex;
 };
 #define SkAutoMutexAcquire(...) SK_REQUIRE_LOCAL_VAR(SkAutoMutexAcquire)
 
 #endif