Extract the spinlock from SkOnce as SkSpinlock.

include/core/SkOnce.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkOnce_DEFINED
 #define SkOnce_DEFINED
 
@@ skipping 10 matching lines @@
 // ...
 // void EnsureRegistered() {
 //     SK_DECLARE_STATIC_ONCE(once);
 //     SkOnce(&once, register_my_stuff, GetGlobalRegistry());
 // }
 //
 // No matter how many times you call EnsureRegistered(), register_my_stuff will be called just once.
 // OnceTest.cpp also should serve as a few other simple examples.
 
 #include "SkAtomics.h"
+#include "SkSpinlock.h"
 
 // This must be used in a global scope, not in fuction scope or as a class member.
 #define SK_DECLARE_STATIC_ONCE(name) namespace {} static SkOnceFlag name
 
 class SkOnceFlag;
 
 inline void SkOnce(SkOnceFlag* once, void (*f)());
 
 template <typename Arg>
 inline void SkOnce(SkOnceFlag* once, void (*f)(Arg), Arg arg);
 
 // If you've already got a lock and a flag to use, this variant lets you avoid an extra SkOnceFlag.
 template <typename Lock>
 inline void SkOnce(bool* done, Lock* lock, void (*f)());
 
 template <typename Lock, typename Arg>
 inline void SkOnce(bool* done, Lock* lock, void (*f)(Arg), Arg arg);
 
 //  ----------------------  Implementation details below here. -----------------------------
 
 // This class has no constructor and must be zero-initialized (the macro above does this).
 class SkOnceFlag {
 public:
     bool* mutableDone() { return &fDone; }
 
-    void acquire() {
-        // To act as a mutex, this needs an acquire barrier on success.
-        // sk_atomic_cas doesn't guarantee this ...
-        while (!sk_atomic_cas(&fSpinlock, 0, 1)) {
-            // spin
-        }
-        // ... so make sure to issue one of our own.
-        SkAssertResult(sk_acquire_load(&fSpinlock));
-    }
-
-    void release() {
-        // To act as a mutex, this needs a release barrier.  sk_atomic_cas guarantees this.
-        SkAssertResult(sk_atomic_cas(&fSpinlock, 1, 0));
-    }
+    void acquire() { fSpinlock.acquire(); }
+    void release() { fSpinlock.release(); }
 
 private:
     bool fDone;
-    int32_t fSpinlock;
+    SkPODSpinlock fSpinlock;
 };
 
 // We've pulled a pretty standard double-checked locking implementation apart
 // into its main fast path and a slow path that's called when we suspect the
 // one-time code hasn't run yet.
 
 // This is the guts of the code, called when we suspect the one-time code hasn't been run yet.
 // This should be rarely called, so we separate it from SkOnce and don't mark it as inline.
 // (We don't mind if this is an actual function call, but odds are it'll be inlined anyway.)
 template <typename Lock, typename Arg>
@@ skipping 57 matching lines @@
 inline void SkOnce(SkOnceFlag* once, void (*func)()) {
     return SkOnce(once, sk_once_no_arg_adaptor, func);
 }
 
 template <typename Lock>
 inline void SkOnce(bool* done, Lock* lock, void (*func)()) {
     return SkOnce(done, lock, sk_once_no_arg_adaptor, func);
 }
 
 #endif  // SkOnce_DEFINED