replace COMPILE_ASSERT with static assert in wtf/

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 582 matching lines @@
     template<unsigned size>
     struct HashTableCapacityForSizeSplitter<size, false> {
         static const unsigned value = UpperPowerOfTwoBound<size>::value;
     };
 
     // HashTableCapacityForSize computes the upper power of two capacity to hold the size parameter.
     // This is done at compile time to initialize the HashTraits.
     template<unsigned size>
     struct HashTableCapacityForSize {
         static const unsigned value = HashTableCapacityForSizeSplitter<size, !(size & (size - 1))>::value;
-        COMPILE_ASSERT(size > 0, HashTableNonZeroMinimumCapacity);
-        COMPILE_ASSERT(!static_cast<int>(value >> 31), HashTableNoCapacityOverflow);
-        COMPILE_ASSERT(value > (2 * size), HashTableCapacityHoldsContentSize);
+        static_assert(size > 0, "HashTable minimum capacity should be > 0");
+        static_assert(!static_cast<int>(value >> 31), "HashTable capacity should not overflow 32bit int");
+        static_assert(value > (2 * size), "HashTable capacity should be able to hold content size");
     };
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     inline HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable()
         : m_table(0)
         , m_tableSize(0)
         , m_keyCount(0)
         , m_deletedCount(0)
         , m_queueFlag(false)
 #if ENABLE(ASSERT)
@@ skipping 370 matching lines @@
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::allocateTable(unsigned size)
     {
         size_t allocSize = size * sizeof(ValueType);
         ValueType* result;
         // Assert that we will not use memset on things with a vtable entry.
         // The compiler will also check this on some platforms. We would
         // like to check this on the whole value (key-value pair), but
         // IsPolymorphic will return false for a pair of two types, even if
         // one of the components is polymorphic.
-        COMPILE_ASSERT(!Traits::emptyValueIsZero || !IsPolymorphic<KeyType>::value, EmptyValueCannotBeZeroForThingsWithAVtable);
+        static_assert(!Traits::emptyValueIsZero || !IsPolymorphic<KeyType>::value, "empty value cannot be zero for things with a vtable");
         if (Traits::emptyValueIsZero) {
             result = Allocator::template allocateZeroedHashTableBacking<ValueType, HashTable>(allocSize);
         } else {
             result = Allocator::template allocateHashTableBacking<ValueType, HashTable>(allocSize);
             for (unsigned i = 0; i < size; i++)
                 initializeBucket(result[i]);
         }
         return result;
     }
 
@@ skipping 371 matching lines @@
         CollectionIterator end(toBeRemoved.end());
         for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
             collection.remove(*it);
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h