Prioritizing input and compositor tasks in the blink scheduler.

Source/wtf/Atomics.h

 /*
  * Copyright (C) 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 60 matching lines @@
     ASSERT(!ret || ret == 1);
     return ret;
 }
 
 ALWAYS_INLINE void atomicSetOneToZero(int volatile* ptr)
 {
     ASSERT(*ptr == 1);
     InterlockedExchange(reinterpret_cast<long volatile*>(ptr), 0);
 }
 
+ALWAYS_INLINE void* atomicTestAndSwap(void* volatile* ptr, void* comprand, void* replacement)
+{
+    return InterlockedCompareExchangePointer(ptr, replacement, comprand);
+}
+
+ALWAYS_INLINE void* atomicExchange(void* volatile* ptr, void* value)
+{
+    return InterlockedExchangePointer(ptr, value);
+}
+
 #else
 
 // atomicAdd returns the result of the addition.
 ALWAYS_INLINE int atomicAdd(int volatile* addend, int increment) { return __sync_add_and_fetch(addend, increment); }
 // atomicSubtract returns the result of the subtraction.
 ALWAYS_INLINE int atomicSubtract(int volatile* addend, int decrement) { return __sync_sub_and_fetch(addend, decrement); }
 
 ALWAYS_INLINE int atomicIncrement(int volatile* addend) { return atomicAdd(addend, 1); }
 ALWAYS_INLINE int atomicDecrement(int volatile* addend) { return atomicSubtract(addend, 1); }
 
 ALWAYS_INLINE int64_t atomicIncrement(int64_t volatile* addend) { return __sync_add_and_fetch(addend, 1); }
 ALWAYS_INLINE int64_t atomicDecrement(int64_t volatile* addend) { return __sync_sub_and_fetch(addend, 1); }
 
 ALWAYS_INLINE int atomicTestAndSetToOne(int volatile* ptr)
 {
     int ret = __sync_lock_test_and_set(ptr, 1);
     ASSERT(!ret || ret == 1);
     return ret;
 }
 
 ALWAYS_INLINE void atomicSetOneToZero(int volatile* ptr)
 {
     ASSERT(*ptr == 1);
     __sync_lock_release(ptr);
 }
+
+ALWAYS_INLINE void* atomicTestAndSwap(void *volatile* ptr, void* comprand, void* replacement)
+{
+    return __sync_val_compare_and_swap(ptr, comprand, replacement);
+}
+
+ALWAYS_INLINE void* atomicExchange(void *volatile* ptr, void* value)
+{
+    return __sync_lock_test_and_set(ptr, value);
+}
+
 #endif
 
 #if defined(THREAD_SANITIZER)
 ALWAYS_INLINE void releaseStore(volatile int* ptr, int value)
 {
     __tsan_atomic32_store(ptr, value, __tsan_memory_order_release);
 }
 
 ALWAYS_INLINE int acquireLoad(volatile const int* ptr)
 {
@@ skipping 40 matching lines @@
     return value;
 }
 
 #undef MEMORY_BARRIER
 
 #endif
 
 } // namespace WTF
 
 using WTF::atomicAdd;
-using WTF::atomicSubtract;
 using WTF::atomicDecrement;
+using WTF::atomicExchange;
 using WTF::atomicIncrement;
 using WTF::atomicTestAndSetToOne;
+using WTF::atomicTestAndSwap;
+using WTF::atomicSubtract;
 using WTF::atomicSetOneToZero;
 using WTF::acquireLoad;
 using WTF::releaseStore;
 
 #endif // Atomics_h