replace COMPILE_ASSERT with static_assert in platform/

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1565 matching lines @@
         index++;
     }
     return index;
 }
 
 template<typename Header>
 HeapPage<Header>::HeapPage(PageMemory* storage, ThreadHeap<Header>* heap, const GCInfo* gcInfo)
     : BaseHeapPage(storage, gcInfo, heap->threadState())
     , m_next(nullptr)
 {
-    COMPILE_ASSERT(!(sizeof(HeapPage<Header>) & allocationMask), page_header_incorrectly_aligned);
+    static_assert(!(sizeof(HeapPage<Header>) & allocationMask), "page header incorrectly aligned");
     m_objectStartBitMapComputed = false;
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 template<typename Header>
 size_t HeapPage<Header>::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     Address headerAddress = payload();
     ASSERT(headerAddress != end());
@@ skipping 508 matching lines @@
 #endif
         return true;
     }
 
 #if ENABLE(ASSERT)
 #define DEFINE_ENSURE_MARKED_METHOD(Type)                                                       \
     virtual bool ensureMarked(const Type* objectPointer) override                               \
     {                                                                                           \
         if (!objectPointer)                                                                     \
             return false;                                                                       \
-        COMPILE_ASSERT(!NeedsAdjustAndMark<Type>::value, CanOnlyUseIsMarkedOnNonAdjustedTypes); \
+        static_assert(!NeedsAdjustAndMark<Type>::value,                                         \
+            "ensureMarked can only be used on non adjusted types");                             \
         if (Mode == ThreadLocalMarking && !objectInTerminatingThreadHeap(objectPointer))        \
             return false;                                                                       \
         if (isMarked(objectPointer))                                                            \
             return false;                                                                       \
         markNoTracing(objectPointer);                                                           \
         return true;                                                                            \
     }
 #else
 #define DEFINE_ENSURE_MARKED_METHOD(Type)                                                       \
     virtual bool ensureMarked(const Type* objectPointer) override                               \
@@ skipping 820 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink