Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/Heap.h

 /*
  * 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 216 matching lines @@
 class PLATFORM_EXPORT ThreadHeap {
  public:
   ThreadHeap();
   ~ThreadHeap();
 
   // Returns true for main thread's heap.
   // TODO(keishi): Per-thread-heap will return false.
   bool isMainThreadHeap() { return this == ThreadHeap::mainThreadHeap(); }
   static ThreadHeap* mainThreadHeap() { return s_mainThreadHeap; }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool isAtSafePoint();
   BasePage* findPageFromAddress(Address);
 #endif
 
   template <typename T>
   static inline bool isHeapObjectAlive(const T* object) {
     static_assert(sizeof(T), "T must be fully defined");
     // The strongification of collections relies on the fact that once a
     // collection has been strongified, there is no way that it can contain
     // non-live entries, so no entries will be removed. Since you can't set
@@ skipping 75 matching lines @@
   // such a reference.
   template <typename T>
   NO_SANITIZE_ADDRESS static bool willObjectBeLazilySwept(
       const T* objectPointer) {
     static_assert(IsGarbageCollectedType<T>::value,
                   "only objects deriving from GarbageCollected can be used.");
     BasePage* page = pageFromObject(objectPointer);
     // Page has been swept and it is still alive.
     if (page->hasBeenSwept())
       return false;
-    ASSERT(page->arena()->getThreadState()->isSweepingInProgress());
+    DCHECK(page->arena()->getThreadState()->isSweepingInProgress());
 
     // If marked and alive, the object hasn't yet been swept..and won't
     // be once its page is processed.
     if (ThreadHeap::isHeapObjectAlive(const_cast<T*>(objectPointer)))
       return false;
 
     if (page->isLargeObjectPage())
       return true;
 
     // If the object is unmarked, it may be on the page currently being
@@ skipping 27 matching lines @@
 
   // Remove an item from the weak callback work list and call the callback
   // with the visitor and the closure pointer.  Returns false when there is
   // nothing more to do.
   bool popAndInvokeGlobalWeakCallback(Visitor*);
 
   // Register an ephemeron table for fixed-point iteration.
   void registerWeakTable(void* containerObject,
                          EphemeronCallback,
                          EphemeronCallback);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool weakTableRegistered(const void*);
 #endif
 
   // Heap compaction registration methods:
 
   // Register |slot| as containing a reference to a movable heap object.
   //
   // When compaction moves the object pointed to by |*slot| to |newAddress|,
   // |*slot| must be updated to hold |newAddress| instead.
   void registerMovingObjectReference(MovableReference*);
@@ skipping 11 matching lines @@
                                     MovingObjectCallback,
                                     void* callbackData);
 
   BlinkGC::GCReason lastGCReason() { return m_lastGCReason; }
   RegionTree* getRegionTree() { return m_regionTree.get(); }
 
   static inline size_t allocationSizeFromSize(size_t size) {
     // Add space for header.
     size_t allocationSize = size + sizeof(HeapObjectHeader);
     // The allocation size calculation can overflow for large sizes.
-    RELEASE_ASSERT(allocationSize > size);
+    CHECK(allocationSize > size);
     // Align size with allocation granularity.
     allocationSize = (allocationSize + allocationMask) & ~allocationMask;
     return allocationSize;
   }
   static Address allocateOnArenaIndex(ThreadState*,
                                       size_t,
                                       int arenaIndex,
                                       size_t gcInfoIndex,
                                       const char* typeName);
   template <typename T>
@@ skipping 18 matching lines @@
 
   FreePagePool* getFreePagePool() { return m_freePagePool.get(); }
   OrphanedPagePool* getOrphanedPagePool() { return m_orphanedPagePool.get(); }
 
   // This look-up uses the region search tree and a negative contains cache to
   // provide an efficient mapping from arbitrary addresses to the containing
   // heap-page if one exists.
   BasePage* lookupPageForAddress(Address);
 
   static const GCInfo* gcInfo(size_t gcInfoIndex) {
-    ASSERT(gcInfoIndex >= 1);
-    ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
-    ASSERT(s_gcInfoTable);
+    DCHECK_GE(gcInfoIndex, 1UL);
+    DCHECK_LT(gcInfoIndex, gcInfoMaxIndex);
+    DCHECK(s_gcInfoTable);
     const GCInfo* info = s_gcInfoTable[gcInfoIndex];
-    ASSERT(info);
+    DCHECK(info);
     return info;
   }
 
   static void reportMemoryUsageHistogram();
   static void reportMemoryUsageForTracing();
 
   HeapCompact* compaction();
 
  private:
   // Reset counters that track live and allocated-since-last-GC sizes.
@@ skipping 52 matching lines @@
   WTF_MAKE_NONCOPYABLE(GarbageCollected);
 
   // For now direct allocation of arrays on the heap is not allowed.
   void* operator new[](size_t size);
 
 #if OS(WIN) && COMPILER(MSVC)
   // Due to some quirkiness in the MSVC compiler we have to provide
   // the delete[] operator in the GarbageCollected subclasses as it
   // is called when a class is exported in a DLL.
  protected:
-  void operator delete[](void* p) { ASSERT_NOT_REACHED(); }
+  void operator delete[](void* p) { NOTREACHED(); }
 #else
   void operator delete[](void* p);
 #endif
 
  public:
   using GarbageCollectedType = T;
 
   void* operator new(size_t size) {
     return allocateObject(size, IsEagerlyFinalizedType<T>::value);
   }
 
   static void* allocateObject(size_t size, bool eagerlySweep) {
     return ThreadHeap::allocate<T>(size, eagerlySweep);
   }
 
-  void operator delete(void* p) { ASSERT_NOT_REACHED(); }
+  void operator delete(void* p) { NOTREACHED(); }
 
  protected:
   GarbageCollected() {}
 };
 
 // Assigning class types to their arenas.
 //
 // We use sized arenas for most 'normal' objects to improve memory locality.
 // It seems that the same type of objects are likely to be accessed together,
 // which means that we want to group objects by type. That's one reason
@@ skipping 27 matching lines @@
          index <= BlinkGC::NormalPage4ArenaIndex;
 }
 
 #define DECLARE_EAGER_FINALIZATION_OPERATOR_NEW() \
  public:                                          \
   GC_PLUGIN_IGNORE("491488")                      \
   void* operator new(size_t size) { return allocateObject(size, true); }
 
 #define IS_EAGERLY_FINALIZED() \
   (pageFromObject(this)->arena()->arenaIndex() == BlinkGC::EagerSweepArenaIndex)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 class VerifyEagerFinalization {
   DISALLOW_NEW();
 
  public:
   ~VerifyEagerFinalization() {
     // If this assert triggers, the class annotated as eagerly
     // finalized ended up not being allocated on the heap
     // set aside for eager finalization. The reason is most
     // likely that the effective 'operator new' overload for
     // this class' leftmost base is for a class that is not
     // eagerly finalized. Declaring and defining an 'operator new'
     // for this class is what's required -- consider using
     // DECLARE_EAGER_FINALIZATION_OPERATOR_NEW().
-    ASSERT(IS_EAGERLY_FINALIZED());
+    DCHECK(IS_EAGERLY_FINALIZED());
   }
 };
 #define EAGERLY_FINALIZE()                           \
  private:                                            \
   VerifyEagerFinalization m_verifyEagerFinalization; \
                                                      \
  public:                                             \
   typedef int IsEagerlyFinalizedMarker
 #else
 #define EAGERLY_FINALIZE() \
  public:                   \
   typedef int IsEagerlyFinalizedMarker
 #endif
 
 inline Address ThreadHeap::allocateOnArenaIndex(ThreadState* state,
                                                 size_t size,
                                                 int arenaIndex,
                                                 size_t gcInfoIndex,
                                                 const char* typeName) {
-  ASSERT(state->isAllocationAllowed());
-  ASSERT(arenaIndex != BlinkGC::LargeObjectArenaIndex);
+  DCHECK(state->isAllocationAllowed());
+  DCHECK_NE(arenaIndex, BlinkGC::LargeObjectArenaIndex);
   NormalPageArena* arena =
       static_cast<NormalPageArena*>(state->arena(arenaIndex));
   Address address =
       arena->allocateObject(allocationSizeFromSize(size), gcInfoIndex);
   HeapAllocHooks::allocationHookIfEnabled(address, size, typeName);
   return address;
 }
 
 template <typename T>
 Address ThreadHeap::allocate(size_t size, bool eagerlySweep) {
@@ skipping 12 matching lines @@
 
   // TODO(sof): promptly free the previous object.
   if (!size) {
     // If the new size is 0 this is considered equivalent to free(previous).
     return nullptr;
   }
 
   ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
   HeapObjectHeader* previousHeader = HeapObjectHeader::fromPayload(previous);
   BasePage* page = pageFromObject(previousHeader);
-  ASSERT(page);
+  DCHECK(page);
 
   // Determine arena index of new allocation.
   int arenaIndex;
   if (size >= largeObjectSizeThreshold) {
     arenaIndex = BlinkGC::LargeObjectArenaIndex;
   } else {
     arenaIndex = page->arena()->arenaIndex();
     if (isNormalArenaIndex(arenaIndex) ||
         arenaIndex == BlinkGC::LargeObjectArenaIndex)
       arenaIndex = arenaIndexForObjectSize(size);
   }
 
   size_t gcInfoIndex = GCInfoTrait<T>::index();
   // TODO(haraken): We don't support reallocate() for finalizable objects.
-  ASSERT(!ThreadHeap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
-  ASSERT(previousHeader->gcInfoIndex() == gcInfoIndex);
+  DCHECK(!ThreadHeap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
+  DCHECK_EQ(previousHeader->gcInfoIndex(), gcInfoIndex);
   HeapAllocHooks::freeHookIfEnabled(static_cast<Address>(previous));
   Address address;
   if (arenaIndex == BlinkGC::LargeObjectArenaIndex) {
     address = page->arena()->allocateLargeObject(allocationSizeFromSize(size),
                                                  gcInfoIndex);
   } else {
     const char* typeName = WTF_HEAP_PROFILER_TYPE_NAME(T);
     address = ThreadHeap::allocateOnArenaIndex(state, size, arenaIndex,
                                                gcInfoIndex, typeName);
   }
   size_t copySize = previousHeader->payloadSize();
   if (copySize > size)
     copySize = size;
   memcpy(address, previous, copySize);
   return address;
 }
 
 template <typename Derived>
 template <typename T>
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* object) {
   T** cell = reinterpret_cast<T**>(object);
   if (*cell && !ObjectAliveTrait<T>::isHeapObjectAlive(*cell))
     *cell = nullptr;
 }
 
 }  // namespace blink
 
 #endif  // Heap_h