Protect AudioScheduledSoureNode::m_startTime and m_endTime.

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 144 matching lines @@
     __tsan_atomic64_store(reinterpret_cast<volatile __tsan_atomic64*>(ptr), static_cast<__tsan_atomic64>(value), __tsan_memory_order_release);
 }
 ALWAYS_INLINE void releaseStore(volatile unsigned long long* ptr, unsigned long long value)
 {
     __tsan_atomic64_store(reinterpret_cast<volatile __tsan_atomic64*>(ptr), static_cast<__tsan_atomic64>(value), __tsan_memory_order_release);
 }
 ALWAYS_INLINE void releaseStore(void* volatile* ptr, void* value)
 {
     __tsan_atomic64_store(reinterpret_cast<volatile __tsan_atomic64*>(ptr), reinterpret_cast<__tsan_atomic64>(value), __tsan_memory_order_release);
 }
+ALWAYS_INLINE void releaseStore(volatile float* ptr, float value)
+{
+    static_assert(sizeof(int) == sizeof(float), "int and float are different sizes");
+    union {
+        int ivalue;
+        float fvalue;
+    } u;
+    u.fvalue = value;
+    __tsan_atomic32_store(reinterpret_cast<volatile __tsan_atomic32*>(ptr), u.ivalue, __tsan_memory_order_release);
+}
+ALWAYS_INLINE void releaseStore(volatile double* ptr, double value)
+{
+    static_assert(sizeof(long) == sizeof(double), "long and double are different sizes");
+    union {
+        long ivalue;
+        double dvalue;
+    } u;
+    u.dvalue = value;
+    __tsan_atomic64_store(reinterpret_cast<volatile __tsan_atomic64*>(ptr), u.ivalue, __tsan_memory_order_release);
+}
 
 ALWAYS_INLINE int acquireLoad(volatile const int* ptr)
 {
     return __tsan_atomic32_load(ptr, __tsan_memory_order_acquire);
 }
 ALWAYS_INLINE unsigned acquireLoad(volatile const unsigned* ptr)
 {
     return static_cast<unsigned>(__tsan_atomic32_load(reinterpret_cast<volatile const int*>(ptr), __tsan_memory_order_acquire));
 }
 ALWAYS_INLINE long acquireLoad(volatile const long* ptr)
 {
     return static_cast<long>(__tsan_atomic64_load(reinterpret_cast<volatile const __tsan_atomic64*>(ptr), __tsan_memory_order_acquire));
 }
 ALWAYS_INLINE unsigned long acquireLoad(volatile const unsigned long* ptr)
 {
     return static_cast<unsigned long>(__tsan_atomic64_load(reinterpret_cast<volatile const __tsan_atomic64*>(ptr), __tsan_memory_order_acquire));
 }
 ALWAYS_INLINE void* acquireLoad(void* volatile const* ptr)
 {
     return reinterpret_cast<void*>(__tsan_atomic64_load(reinterpret_cast<volatile const __tsan_atomic64*>(ptr), __tsan_memory_order_acquire));
 }
+ALWAYS_INLINE float acquireLoad(volatile const float* ptr)
+{
+    static_assert(sizeof(int) == sizeof(float), "int and float are different sizes");
+    union {
+        int ivalue;
+        float fvalue;
+    } u;
+    u.ivalue = __tsan_atomic32_load(reinterpret_cast<volatile const int*>(ptr), __tsan_memory_order_acquire);
+    return u.fvalue;
+}
+ALWAYS_INLINE double acquireLoad(volatile const double* ptr)
+{
+    static_assert(sizeof(long) == sizeof(double), "long and double are different sizes");
+    union {
+        long ivalue;
+        double dvalue;
+    } u;
+    u.ivalue = static_cast<long>(__tsan_atomic64_load(reinterpret_cast<volatile const __tsan_atomic64*>(ptr), __tsan_memory_order_acquire));
+    return u.dvalue;
+}
 #endif
 
 #else // defined(THREAD_SANITIZER)
 
 #if CPU(X86) || CPU(X86_64)
 // Only compiler barrier is needed.
 #if COMPILER(MSVC)
 // Starting from Visual Studio 2005 compiler guarantees acquire and release
 // semantics for operations on volatile variables. See MSDN entry for
 // MemoryBarrier macro.
@@ skipping 40 matching lines @@
 ALWAYS_INLINE void releaseStore(volatile unsigned long long* ptr, unsigned long long value)
 {
     MEMORY_BARRIER();
     *ptr = value;
 }
 ALWAYS_INLINE void releaseStore(void* volatile* ptr, void* value)
 {
     MEMORY_BARRIER();
     *ptr = value;
 }
+ALWAYS_INLINE void releaseStore(volatile float* ptr, float value)
+{
+    MEMORY_BARRIER();
+    *ptr = value;
+}
+ALWAYS_INLINE void releaseStore(volatile double* ptr, double value)
+{
+    MEMORY_BARRIER();
+    *ptr = value;
+}
 
+
 ALWAYS_INLINE int acquireLoad(volatile const int* ptr)
 {
     int value = *ptr;
     MEMORY_BARRIER();
     return value;
 }
 ALWAYS_INLINE unsigned acquireLoad(volatile const unsigned* ptr)
 {
     unsigned value = *ptr;
     MEMORY_BARRIER();
     return value;
 }
 ALWAYS_INLINE long acquireLoad(volatile const long* ptr)
 {
     long value = *ptr;
     MEMORY_BARRIER();
     return value;
 }
 ALWAYS_INLINE unsigned long acquireLoad(volatile const unsigned long* ptr)
 {
     unsigned long value = *ptr;
     MEMORY_BARRIER();
     return value;
 }
 ALWAYS_INLINE unsigned long long acquireLoad(volatile const unsigned long long* ptr)
 {
     unsigned long long value = *ptr;

[Alexander Potapenko, 2015/08/10 14:01:30]

Just noticed that this function (and the corresponding releaseStore()
implementation) is broken on 32-bit platforms. The compiler will most likely
emit several instructions for this line (3 instructions for x86), making the
access nonatomic.
This function must be enabled for 64-architectures only.

[Raymond Toy, 2015/08/10 16:36:42]

I think a bug should be filed for that and fixed in a separate CL. Since it's
defined, presumably it's being used somewhere by someone.

[tkent, 2015/08/11 00:41:28]

I filed crbug.com/519096 .

     MEMORY_BARRIER();
     return value;
 }
 ALWAYS_INLINE void* acquireLoad(void* volatile const* ptr)
 {
     void* value = *ptr;
     MEMORY_BARRIER();
     return value;
 }
+ALWAYS_INLINE float acquireLoad(volatile const float* ptr)
+{
+    float value = *ptr;
+    MEMORY_BARRIER();
+    return value;
+}
+ALWAYS_INLINE double acquireLoad(volatile const double* ptr)

[Alexander Potapenko, 2015/08/10 14:01:30]

I'm no expert in ARM CPUs, do you have an idea whether 32-bit ARM supports
atomic 64-bit float loads/stores?
From what I could find I see that LDRD is executed as a sequence of two 32-bit
loads. If so, this implementation is not correct for ARM-32.

+{
+    double value = *ptr;
+    MEMORY_BARRIER();
+    return value;
+}
 
 #if defined(ADDRESS_SANITIZER)
 
 NO_SANITIZE_ADDRESS ALWAYS_INLINE void asanUnsafeReleaseStore(volatile unsigned* ptr, unsigned value)
 {
     MEMORY_BARRIER();
     *ptr = value;
 }
 
 NO_SANITIZE_ADDRESS ALWAYS_INLINE unsigned asanUnsafeAcquireLoad(volatile const unsigned* ptr)
@@ skipping 34 matching lines @@
 using WTF::acquireLoad;
 using WTF::releaseStore;
 
 // These methods allow loading from and storing to poisoned memory. Only
 // use these methods if you know what you are doing since they will
 // silence use-after-poison errors from ASan.
 using WTF::asanUnsafeAcquireLoad;
 using WTF::asanUnsafeReleaseStore;
 
 #endif // Atomics_h