Improve Skia configuration.

skia/ext/SkAtomics_chromium.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/skia/include/core/SkThread.h"
-
-#include <new>
+#ifndef SkAtomics_chrome_DEFINED
+#define SkAtomics_chrome_DEFINED
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/synchronization/lock.h"
 
-/** Adds one to the int specified by the address (in a thread-safe manner), and
-    returns the previous value.
-    No additional memory barrier is required.
-    This must act as a compiler barrier.
-*/
-int32_t sk_atomic_inc(int32_t* addr) {
+/** Atomic add one to the int and return the previous value.
+ *  No memory barrier is required; must act as a compiler barrier.
+ */
+static inline int32_t sk_atomic_inc(int32_t* addr) {
   // sk_atomic_inc is expected to return the old value,
-  // Barrier_AtomicIncrement returns the new value.
+  // NoBarrier_AtomicIncrement returns the new value.
   return base::subtle::NoBarrier_AtomicIncrement(addr, 1) - 1;
 }
 
-/*  Subtracts one from the int specified by the address (in a thread-safe
-    manner), and returns the previous value.
-    Expected to act as a release (SL/S) memory barrier and a compiler barrier.
-*/
-int32_t sk_atomic_dec(int32_t* addr) {
+/** Atomic add inc to the int return the previous value.
+ *  No memory barrier is required; must act as a compiler barrier.
+ */
+static inline int32_t sk_atomic_add(int32_t* addr, int32_t inc) {
+  // sk_atomic_add is expected to return the old value,
+  // Barrier_AtomicIncrement returns the new value.
+  return base::subtle::Barrier_AtomicIncrement(addr, inc) - inc;
+}
+
+/** Atomic subtracts one from the int and return the previous value.
+ *  Must act as a release (SL/S) memory barrier and as a compiler barrier.
+ */
+static inline int32_t sk_atomic_dec(int32_t* addr) {
   // sk_atomic_dec is expected to return the old value,
   // Barrier_AtomicIncrement returns the new value.
   return base::subtle::Barrier_AtomicIncrement(addr, -1) + 1;
 }
-/** If sk_atomic_dec does not act as an aquire (L/SL) barrier, this is expected
-    to act as an aquire (L/SL) memory barrier and as a compiler barrier.
-*/
-void sk_membar_aquire__after_atomic_dec() { }
+/** If sk_atomic_dec does not act as an acquire (L/SL) barrier,
+ *  must act as an acquire (L/SL) memory barrier and as a compiler barrier.
+ */
+static inline void sk_membar_acquire__after_atomic_dec() { }
 
-/** Adds one to the int specified by the address iff the int specified by the
-    address is not zero (in a thread-safe manner), and returns the previous
-    value.
-    No additional memory barrier is required.
-    This must act as a compiler barrier.
-*/
-int32_t sk_atomic_conditional_inc(int32_t* addr) {
+/** Atomic add one to the int iff the int was not 0; return the previous value.
+ *  No memory barrier is required; must act as a compiler barrier.
+ */
+static inline int32_t sk_atomic_conditional_inc(int32_t* addr) {
     int32_t value = *addr;
 
     while (true) {
         if (value == 0) {
             return 0;
         }
 
         int32_t before;
         before = base::subtle::Acquire_CompareAndSwap(addr, value, value + 1);
 
         if (before == value) {
             return value;
         } else {
             value = before;
         }
     }
 }
-/** If sk_atomic_conditional_inc does not act as an aquire (L/SL) barrier, this
-    is expected to act as an aquire (L/SL) memory barrier and as a compiler
-    barrier.
+/** If sk_atomic_conditional_inc does not act as an acquire (L/SL) barrier,
+ *  must act as an acquire (L/SL) memory barrier and as a compiler barrier.
+ */
+static inline void sk_membar_acquire__after_atomic_conditional_inc() { }
+
+/** Atomically load the int.
+ *  Must act as an acquire (L/SL) memory barrier and as a compiler barrier.
 */
-void sk_membar_aquire__after_atomic_conditional_inc() { }
-
-SkMutex::SkMutex() {
-  COMPILE_ASSERT(sizeof(base::Lock) <= sizeof(fStorage), Lock_is_too_big_for_SkMutex);
-  base::Lock* lock = reinterpret_cast<base::Lock*>(fStorage);
-  new(lock) base::Lock();
+static inline int32_t sk_atomic_load_acquire(int32_t* addr) {
+    return base::subtle::Acquire_Load(addr);
 }
 
-SkMutex::~SkMutex() {
-  base::Lock* lock = reinterpret_cast<base::Lock*>(fStorage);
-  lock->~Lock();
-}
+#endif
 
-void SkMutex::acquire() {
-  base::Lock* lock = reinterpret_cast<base::Lock*>(fStorage);
-  lock->Acquire();
-}
-
-void SkMutex::release() {
-  base::Lock* lock = reinterpret_cast<base::Lock*>(fStorage);
-  lock->Release();
-}