Replace ASSERTs in platform/heap/ with DCHECKs

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PageMemory_h
 #define PageMemory_h
 
 #include "platform/heap/HeapPage.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Compiler.h"
 #include "wtf/allocator/Partitions.h"
 
 #if OS(POSIX)
 #include <sys/mman.h>
 #include <unistd.h>
 #endif
 
 namespace blink {
 
 class RegionTree;
 class RegionTreeNode;
 
 class MemoryRegion {
   USING_FAST_MALLOC(MemoryRegion);
 
  public:
   MemoryRegion(Address base, size_t size) : m_base(base), m_size(size) {
-    ASSERT(size > 0);
+    DCHECK_GT(size, 0UL);
   }
 
   bool contains(Address addr) const {
     return m_base <= addr && addr < (m_base + m_size);
   }
 
   bool contains(const MemoryRegion& other) const {
     return contains(other.m_base) && contains(other.m_base + other.m_size - 1);
   }
 
@@ skipping 15 matching lines @@
 // whole. The PageMemoryRegion allows us to do that by keeping track
 // of the number of pages using it in order to be able to release all
 // of the virtual address space when there are no more pages using it.
 class PageMemoryRegion : public MemoryRegion {
  public:
   ~PageMemoryRegion();
 
   void pageDeleted(Address);
 
   void markPageUsed(Address page) {
-    ASSERT(!m_inUse[index(page)]);
+    DCHECK(!m_inUse[index(page)]);
     m_inUse[index(page)] = true;
   }
 
   void markPageUnused(Address page) { m_inUse[index(page)] = false; }
 
   static PageMemoryRegion* allocateLargePage(size_t size,
                                              RegionTree* regionTree) {
     return allocate(size, 1, regionTree);
   }
 
   static PageMemoryRegion* allocateNormalPages(RegionTree* regionTree) {
     return allocate(blinkPageSize * blinkPagesPerRegion, blinkPagesPerRegion,
                     regionTree);
   }
 
   BasePage* pageFromAddress(Address address) {
-    ASSERT(contains(address));
+    DCHECK(contains(address));
     if (!m_inUse[index(address)])
       return nullptr;
     if (m_isLargePage)
       return pageFromObject(base());
     return pageFromObject(address);
   }
 
  private:
   PageMemoryRegion(Address base, size_t, unsigned numPages, RegionTree*);
 
   unsigned index(Address address) const {
-    ASSERT(contains(address));
+    DCHECK(contains(address));
     if (m_isLargePage)
       return 0;
     size_t offset = blinkPageAddress(address) - base();
-    ASSERT(offset % blinkPageSize == 0);
+    DCHECK_EQ(offset % blinkPageSize, 0UL);
     return offset / blinkPageSize;
   }
 
   static PageMemoryRegion* allocate(size_t, unsigned numPages, RegionTree*);
 
   const bool m_isLargePage;
   // A thread owns a page, but not a region. Represent the in-use
   // bitmap such that thread non-interference comes for free.
   bool m_inUse[blinkPagesPerRegion];
   int m_numPages;
@@ skipping 96 matching lines @@
  private:
   PageMemory(PageMemoryRegion* reserved, const MemoryRegion& writable);
 
   PageMemoryRegion* m_reserved;
   MemoryRegion m_writable;
 };
 
 }  // namespace blink
 
 #endif