Replace ASSERT with DHCECK_op in platform/heap

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 "platform/wtf/Allocator.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Compiler.h"
 #include "platform/wtf/allocator/Partitions.h"
 
 namespace blink {
 
 class RegionTree;
 class RegionTreeNode;
 
 class MemoryRegion {
   USING_FAST_MALLOC(MemoryRegion);
 
  public:
   MemoryRegion(Address base, size_t size) : base_(base), size_(size) {
-    ASSERT(size > 0);
+    DCHECK_GT(size, 0u);
   }
 
   bool Contains(Address addr) const {
     return base_ <= addr && addr < (base_ + size_);
   }
 
   bool Contains(const MemoryRegion& other) const {
     return Contains(other.base_) && Contains(other.base_ + other.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(!in_use_[Index(page)]);
+    DCHECK(!in_use_[Index(page)]);
     in_use_[Index(page)] = true;
   }
 
   void MarkPageUnused(Address page) { in_use_[Index(page)] = false; }
 
   static PageMemoryRegion* AllocateLargePage(size_t size,
                                              RegionTree* region_tree) {
     return Allocate(size, 1, region_tree);
   }
 
   static PageMemoryRegion* AllocateNormalPages(RegionTree* region_tree) {
     return Allocate(kBlinkPageSize * kBlinkPagesPerRegion, kBlinkPagesPerRegion,
                     region_tree);
   }
 
   BasePage* PageFromAddress(Address address) {
-    ASSERT(Contains(address));
+    DCHECK(Contains(address));
     if (!in_use_[Index(address)])
       return nullptr;
     if (is_large_page_)
       return PageFromObject(Base());
     return PageFromObject(address);
   }
 
  private:
   PageMemoryRegion(Address base, size_t, unsigned num_pages, RegionTree*);
 
   unsigned Index(Address address) const {
-    ASSERT(Contains(address));
+    DCHECK(Contains(address));
     if (is_large_page_)
       return 0;
     size_t offset = BlinkPageAddress(address) - Base();
-    ASSERT(offset % kBlinkPageSize == 0);
+    DCHECK_EQ(offset % kBlinkPageSize, 0u);
     return offset / kBlinkPageSize;
   }
 
   static PageMemoryRegion* Allocate(size_t, unsigned num_pages, RegionTree*);
 
   const bool is_large_page_;
   // A thread owns a page, but not a region. Represent the in-use
   // bitmap such that thread non-interference comes for free.
   bool in_use_[kBlinkPagesPerRegion];
   int num_pages_;
@@ skipping 104 matching lines @@
  private:
   PageMemory(PageMemoryRegion* reserved, const MemoryRegion& writable);
 
   PageMemoryRegion* reserved_;
   MemoryRegion writable_;
 };
 
 }  // namespace blink
 
 #endif