replace COMPILE_ASSERT with static assert in wtf/

Source/wtf/PassOwnPtr.h

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 55 matching lines @@
         typedef PtrType PassOwnPtr::*UnspecifiedBoolType;
         operator UnspecifiedBoolType() const { return m_ptr ? &PassOwnPtr::m_ptr : 0; }
 
         template<typename U> friend PassOwnPtr<U> adoptPtr(U*);
         template<typename U> friend PassOwnPtr<U[]> adoptArrayPtr(U*);
         template<typename U> friend class OwnPtr;
 
     private:
         explicit PassOwnPtr(PtrType ptr) : m_ptr(ptr) { }
 
-        PassOwnPtr& operator=(const PassOwnPtr&) { COMPILE_ASSERT(!sizeof(T*), PassOwnPtr_should_never_be_assigned_to); return *this; }
+        PassOwnPtr& operator=(const PassOwnPtr&) { static_assert(!sizeof(T*), "PassOwnPtr should never be assigned to"); return *this; }
 
         // We should never have two OwnPtrs for the same underlying object (otherwise we'll get
         // double-destruction), so these equality operators should never be needed.
-        template<typename U> bool operator==(const PassOwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
-        template<typename U> bool operator!=(const PassOwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
-        template<typename U> bool operator==(const OwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
-        template<typename U> bool operator!=(const OwnPtr<U>&) const { COMPILE_ASSERT(!sizeof(U*), OwnPtrs_should_never_be_equal); return false; }
+        template<typename U> bool operator==(const PassOwnPtr<U>&) const { static_assert(!sizeof(U*), "OwnPtrs should never be equal"); return false; }
+        template<typename U> bool operator!=(const PassOwnPtr<U>&) const { static_assert(!sizeof(U*), "OwnPtrs should never be equal"); return false; }
+        template<typename U> bool operator==(const OwnPtr<U>&) const { static_assert(!sizeof(U*), "OwnPtrs should never be equal"); return false; }
+        template<typename U> bool operator!=(const OwnPtr<U>&) const { static_assert(!sizeof(U*), "OwnPtrs should never be equal"); return false; }
 
         mutable PtrType m_ptr;
     };
 
     template<typename T> template<typename U> inline PassOwnPtr<T>::PassOwnPtr(const PassOwnPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
         : m_ptr(o.leakPtr())
     {
-        COMPILE_ASSERT(!IsArray<T>::value, Pointers_to_array_must_never_be_converted);
+        static_assert(!IsArray<T>::value, "pointers to array must never be converted");
     }
 
     template<typename T> inline typename PassOwnPtr<T>::PtrType PassOwnPtr<T>::leakPtr() const
     {
         PtrType ptr = m_ptr;
         m_ptr = 0;
         return ptr;
     }
 
     template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, U* b)
@@ skipping 21 matching lines @@
         return PassOwnPtr<T>(ptr);
     }
 
     template<typename T> inline PassOwnPtr<T[]> adoptArrayPtr(T* ptr)
     {
         return PassOwnPtr<T[]>(ptr);
     }
 
     template<typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p)
     {
-        COMPILE_ASSERT(!IsArray<T>::value, Pointers_to_array_must_never_be_converted);
+        static_assert(!IsArray<T>::value, "pointers to array must never be converted");
         return adoptPtr(static_cast<T*>(p.leakPtr()));
     }
 
     template<typename T> inline T* getPtr(const PassOwnPtr<T>& p)
     {
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::PassOwnPtr;
 using WTF::adoptPtr;
 using WTF::adoptArrayPtr;
 using WTF::static_pointer_cast;
 
 #endif // WTF_PassOwnPtr_h