Move sync code to include/, switch from using platform define to a proxy header in core/

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
 
 #include "SkTypes.h"
 
-// SK_ATOMICS_PLATFORM_H must provide inline implementations for the following declarations.
+// SkAtomics.h must provide inline implementations for the following declarations.
 
 /** Atomically adds one to the int referenced by addr and returns the previous value.
  *  No additional memory barrier is required; this must act as a compiler barrier.
  */
 static int32_t sk_atomic_inc(int32_t* addr);
 static int64_t sk_atomic_inc(int64_t* addr);
 
 /** Atomically adds inc to the int referenced by addr and returns the previous value.
  *  No additional memory barrier is required; this must act as a compiler barrier.
  */
@@ skipping 13 matching lines @@
 /** 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();
 
-#ifdef GOOGLE3
-    #include "SkAtomics_sync.h"
-#else
-    #include SK_ATOMICS_PLATFORM_H
-#endif
+#include "SkAtomics.h"
 
 /** 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.
  */
 template<typename INT_TYPE> static inline INT_TYPE sk_atomic_conditional_inc(INT_TYPE* addr) {
     INT_TYPE prev;
     do {
         prev = *addr;
         if (0 == prev) {
             break;
         }
     } while (!sk_atomic_cas(addr, prev, prev+1));
     return prev;
 }
 
-// SK_BARRIERS_PLATFORM_H must provide implementations for the following declarations:
+// SkBarriers.h must provide implementations for the following declarations:
 
 /** Prevent the compiler from reordering across this barrier. */
 static void sk_compiler_barrier();
 
 /** Read T*, with at least an acquire barrier.
  *
  *  Only needs to be implemented for T which can be atomically read.
  */
 template <typename T> T sk_acquire_load(T*);
 
 /** Write T*, with at least a release barrier.
  *
  *  Only needs to be implemented for T which can be atomically written.
  */
 template <typename T> void sk_release_store(T*, T);
 
-#ifdef GOOGLE3
-    #include "SkBarriers_x86.h"
-#else
-    #include SK_BARRIERS_PLATFORM_H
-#endif
+#include "SkBarriers.h"
 
-/** SK_MUTEX_PLATFORM_H must provide the following (or equivalent) declarations.
+/** SkMutex.h must provide the following (or equivalent) declarations.
 
 class SkBaseMutex {
 public:
     void acquire();     // Block until this thread owns the mutex.
     void release();     // Assuming this thread owns the mutex, release it.
     void assertHeld();  // If SK_DEBUG, assert this thread owns the mutex.
 };
 
 class SkMutex : SkBaseMutex {
 public:
     SkMutex();
     ~SkMutex();
 };
 
 #define SK_DECLARE_STATIC_MUTEX(name) static SkBaseMutex name = ...
 */
 
-#ifdef GOOGLE3
-    #include "SkMutex_pthread.h"
-#else
-    #include SK_MUTEX_PLATFORM_H
-#endif
-
+#include "SkMutex.h"
 
 class SkAutoMutexAcquire : SkNoncopyable {
 public:
     explicit SkAutoMutexAcquire(SkBaseMutex& mutex) : fMutex(&mutex) {
         SkASSERT(fMutex != NULL);
         mutex.acquire();
     }
 
     explicit SkAutoMutexAcquire(SkBaseMutex* mutex) : fMutex(mutex) {
         if (mutex) {
@@ skipping 21 matching lines @@
         SkASSERT(fMutex);
         fMutex->assertHeld();
     }
 
 private:
     SkBaseMutex* fMutex;
 };
 #define SkAutoMutexAcquire(...) SK_REQUIRE_LOCAL_VAR(SkAutoMutexAcquire)
 
 #endif