Split atomic and mutex implementations and make inlinable.

include/core/SkWeakRefCnt.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkWeakRefCnt_DEFINED
 #define SkWeakRefCnt_DEFINED
 
@@ skipping 71 matching lines @@
 
     /** Creates a strong reference from a weak reference, if possible. The
         caller must already be an owner. If try_ref() returns true the owner
         is in posession of an additional strong reference. Both the original
         reference and new reference must be properly unreferenced. If try_ref()
         returns false, no strong reference could be created and the owner's
         reference is in the same state as before the call.
     */
     bool SK_WARN_UNUSED_RESULT try_ref() const {
         if (sk_atomic_conditional_inc(&fRefCnt) != 0) {
-            // Aquire barrier (L/SL), if not provided above.
+            // Acquire barrier (L/SL), if not provided above.
             // Prevents subsequent code from happening before the increment.
-            sk_membar_aquire__after_atomic_conditional_inc();
+            sk_membar_acquire__after_atomic_conditional_inc();
             return true;
         }
         return false;
     }
 
     /** Increment the weak reference count. Must be balanced by a call to
         weak_unref().
     */
     void weak_ref() const {
         SkASSERT(fRefCnt > 0);
         SkASSERT(fWeakCnt > 0);
         sk_atomic_inc(&fWeakCnt);  // No barrier required.
     }
 
     /** Decrement the weak reference count. If the weak reference count is 1
         before the decrement, then call delete on the object. Note that if this
         is the case, then the object needs to have been allocated via new, and
         not on the stack.
     */
     void weak_unref() const {
         SkASSERT(fWeakCnt > 0);
         // Release barrier (SL/S), if not provided below.
         if (sk_atomic_dec(&fWeakCnt) == 1) {
-            // Aquire barrier (L/SL), if not provided above.
+            // Acquire barrier (L/SL), if not provided above.
             // Prevents code in destructor from happening before the decrement.
-            sk_membar_aquire__after_atomic_dec();
+            sk_membar_acquire__after_atomic_dec();
 #ifdef SK_DEBUG
             // so our destructor won't complain
             fWeakCnt = 1;
 #endif
             this->INHERITED::internal_dispose();
         }
     }
 
     /** Returns true if there are no strong references to the object. When this
         is the case all future calls to try_ref() will return false.
@@ skipping 21 matching lines @@
         weak_unref();
     }
 
     /* Invariant: fWeakCnt = #weak + (fRefCnt > 0 ? 1 : 0) */
     mutable int32_t fWeakCnt;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif