Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/HeapPage.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 169 matching lines @@
     // |allocationGranurarity|, |HeapObjectHeader| must fit into the size.
     static_assert(
         sizeof(HeapObjectHeader) <= kAllocationGranularity,
         "size of HeapObjectHeader must be smaller than allocationGranularity");
 #if CPU(64BIT)
     static_assert(sizeof(HeapObjectHeader) == 8,
                   "sizeof(HeapObjectHeader) must be 8 bytes");
     magic_ = GetMagic();
 #endif
 
-    ASSERT(gc_info_index < GCInfoTable::kMaxIndex);
-    ASSERT(size < kNonLargeObjectPageSizeMax);
-    ASSERT(!(size & kAllocationMask));
+    DCHECK(gc_info_index < GCInfoTable::kMaxIndex);

[Hwanseung Lee, 2017/04/20 00:30:43]

when replaced to DCHECK_LT, it was cause of build fail.

+    DCHECK_LT(size, kNonLargeObjectPageSizeMax);
+    DCHECK(!(size & kAllocationMask));
     encoded_ = static_cast<uint32_t>(
         (gc_info_index << kHeaderGCInfoIndexShift) | size |
         (gc_info_index == kGcInfoIndexForFreeListHeader ? kHeaderFreedBitMask
                                                         : 0));
   }
 
   NO_SANITIZE_ADDRESS bool IsFree() const {
     return encoded_ & kHeaderFreedBitMask;
   }
 
   NO_SANITIZE_ADDRESS bool IsPromptlyFreed() const {
     return (encoded_ & kHeaderPromptlyFreedBitMask) ==
            kHeaderPromptlyFreedBitMask;
   }
 
   NO_SANITIZE_ADDRESS void MarkPromptlyFreed() {
     encoded_ |= kHeaderPromptlyFreedBitMask;
   }
 
   size_t size() const;
 
   NO_SANITIZE_ADDRESS size_t GcInfoIndex() const {
     return (encoded_ & kHeaderGCInfoIndexMask) >> kHeaderGCInfoIndexShift;
   }
 
   NO_SANITIZE_ADDRESS void SetSize(size_t size) {
-    ASSERT(size < kNonLargeObjectPageSizeMax);
+    DCHECK_LT(size, kNonLargeObjectPageSizeMax);
     CheckHeader();
     encoded_ = static_cast<uint32_t>(size) | (encoded_ & ~kHeaderSizeMask);
   }
 
   bool IsWrapperHeaderMarked() const;
   void MarkWrapperHeader();
   void UnmarkWrapperHeader();
   bool IsMarked() const;
   void Mark();
   void Unmark();
@@ skipping 38 matching lines @@
 
   uint32_t encoded_;
 };
 
 class FreeListEntry final : public HeapObjectHeader {
  public:
   NO_SANITIZE_ADDRESS
   explicit FreeListEntry(size_t size)
       : HeapObjectHeader(size, kGcInfoIndexForFreeListHeader), next_(nullptr) {
 #if DCHECK_IS_ON() && CPU(64BIT)
-    ASSERT(size >= sizeof(HeapObjectHeader));
+    DCHECK_GE(size, sizeof(HeapObjectHeader));
     ZapMagic();
 #endif
   }
 
   Address GetAddress() { return reinterpret_cast<Address>(this); }
 
   NO_SANITIZE_ADDRESS
   void Unlink(FreeListEntry** prev_next) {
     *prev_next = next_;
     next_ = nullptr;
   }
 
   NO_SANITIZE_ADDRESS
   void Link(FreeListEntry** prev_next) {
     next_ = *prev_next;
     *prev_next = this;
   }
 
   NO_SANITIZE_ADDRESS
   FreeListEntry* Next() const { return next_; }
 
   NO_SANITIZE_ADDRESS
   void Append(FreeListEntry* next) {
-    ASSERT(!next_);
+    DCHECK(!next_);
     next_ = next;
   }
 
  private:
   FreeListEntry* next_;
 };
 
 // Blink heap pages are set up with a guard page before and after the payload.
 inline size_t BlinkPagePayloadSize() {
   return kBlinkPageSize - 2 * kBlinkGuardPageSize;
@@ skipping 114 matching lines @@
   virtual bool IsLargeObjectPage() { return false; }
 
   Address GetAddress() { return reinterpret_cast<Address>(this); }
   PageMemory* Storage() const { return storage_; }
   BaseArena* Arena() const { return arena_; }
 
   // Returns true if this page has been swept by the ongoing lazy sweep.
   bool HasBeenSwept() const { return swept_; }
 
   void MarkAsSwept() {
-    ASSERT(!swept_);
+    DCHECK(!swept_);
     swept_ = true;
   }
 
   void MarkAsUnswept() {
-    ASSERT(swept_);
+    DCHECK(swept_);
     swept_ = false;
   }
 
  private:
   PageMemory* storage_;
   BaseArena* arena_;
   BasePage* next_;
 
   // Track the sweeping state of a page. Set to false at the start of a sweep,
   // true  upon completion of lazy sweeping.
@@ skipping 293 matching lines @@
 
   // Index into the page pools. This is used to ensure that the pages of the
   // same type go into the correct page pool and thus avoid type confusion.
   int index_;
 };
 
 class PLATFORM_EXPORT NormalPageArena final : public BaseArena {
  public:
   NormalPageArena(ThreadState*, int);
   void AddToFreeList(Address address, size_t size) {
-    ASSERT(FindPageFromAddress(address));
-    ASSERT(FindPageFromAddress(address + size - 1));
+#if DCHECK_IS_ON()
+    DCHECK(FindPageFromAddress(address));
+    DCHECK(FindPageFromAddress(address + size - 1));
+#endif
     free_list_.AddToFreeList(address, size);
   }
   void ClearFreeLists() override;
 #if DCHECK_IS_ON()
   bool IsConsistentForGC() override;
   bool PagesToBeSweptContains(Address);
 #endif
   void TakeFreelistSnapshot(const String& dump_base_name) override;
 
   Address AllocateObject(size_t allocation_size, size_t gc_info_index);
@@ skipping 62 matching lines @@
 
 // Mask an address down to the enclosing oilpan heap base page. All Oilpan heap
 // pages are aligned at |blinkPageBase| plus the size of a guard size.
 //
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed arenas. This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BasePage* PageFromObject(const void* object) {
   Address address = reinterpret_cast<Address>(const_cast<void*>(object));
   BasePage* page = reinterpret_cast<BasePage*>(BlinkPageAddress(address) +
                                                kBlinkGuardPageSize);
-  ASSERT(page->Contains(address));
+#if DCHECK_IS_ON()
+  DCHECK(page->Contains(address));
+#endif
   return page;
 }
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::size() const {
   size_t result = encoded_ & kHeaderSizeMask;
   // Large objects should not refer to header->size(). The actual size of a
   // large object is stored in |LargeObjectPage::m_payloadSize|.
-  ASSERT(result != kLargeObjectSizeInHeader);
-  ASSERT(!PageFromObject(this)->IsLargeObjectPage());
+  DCHECK(result != kLargeObjectSizeInHeader);
+  DCHECK(!PageFromObject(this)->IsLargeObjectPage());
   return result;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::CheckHeader() const {
 #if CPU(64BIT)
   const bool good_magic = GetMagic() == magic_;
   DCHECK(good_magic);
 #endif
 }
 
 inline Address HeapObjectHeader::Payload() {
   return reinterpret_cast<Address>(this) + sizeof(HeapObjectHeader);
 }
 
 inline Address HeapObjectHeader::PayloadEnd() {
   return reinterpret_cast<Address>(this) + size();
 }
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::PayloadSize() {
   CheckHeader();
   size_t size = encoded_ & kHeaderSizeMask;
   if (UNLIKELY(size == kLargeObjectSizeInHeader)) {
-    ASSERT(PageFromObject(this)->IsLargeObjectPage());
+    DCHECK(PageFromObject(this)->IsLargeObjectPage());
     return static_cast<LargeObjectPage*>(PageFromObject(this))->PayloadSize();
   }
-  ASSERT(!PageFromObject(this)->IsLargeObjectPage());
+  DCHECK(!PageFromObject(this)->IsLargeObjectPage());
   return size - sizeof(HeapObjectHeader);
 }
 
 inline HeapObjectHeader* HeapObjectHeader::FromPayload(const void* payload) {
   Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
   HeapObjectHeader* header =
       reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
   header->CheckHeader();
   return header;
 }
@@ skipping 57 matching lines @@
 #endif  // CPU(64BIT)
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::IsWrapperHeaderMarked()
     const {
   CheckHeader();
   return encoded_ & kHeaderWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::MarkWrapperHeader() {
   CheckHeader();
-  ASSERT(!IsWrapperHeaderMarked());
+  DCHECK(!IsWrapperHeaderMarked());
   encoded_ |= kHeaderWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::UnmarkWrapperHeader() {
   CheckHeader();
-  ASSERT(IsWrapperHeaderMarked());
+  DCHECK(IsWrapperHeaderMarked());
   encoded_ &= ~kHeaderWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::IsMarked() const {
   CheckHeader();
   return encoded_ & kHeaderMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::Mark() {
   CheckHeader();
-  ASSERT(!IsMarked());
+  DCHECK(!IsMarked());
   encoded_ = encoded_ | kHeaderMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::Unmark() {
   CheckHeader();
-  ASSERT(IsMarked());
+  DCHECK(IsMarked());
   encoded_ &= ~kHeaderMarkBitMask;
 }
 
 inline Address NormalPageArena::AllocateObject(size_t allocation_size,
                                                size_t gc_info_index) {
   if (LIKELY(allocation_size <= remaining_allocation_size_)) {
     Address header_address = current_allocation_point_;
     current_allocation_point_ += allocation_size;
     remaining_allocation_size_ -= allocation_size;
-    ASSERT(gc_info_index > 0);
+    DCHECK_GT(gc_info_index, 0u);
     new (NotNull, header_address)
         HeapObjectHeader(allocation_size, gc_info_index);
     Address result = header_address + sizeof(HeapObjectHeader);
-    ASSERT(!(reinterpret_cast<uintptr_t>(result) & kAllocationMask));
+    DCHECK(!(reinterpret_cast<uintptr_t>(result) & kAllocationMask));
 
     SET_MEMORY_ACCESSIBLE(result, allocation_size - sizeof(HeapObjectHeader));
-    ASSERT(FindPageFromAddress(header_address + allocation_size - 1));
+#if DCHECK_IS_ON()
+    DCHECK(FindPageFromAddress(header_address + allocation_size - 1));
+#endif
     return result;
   }
   return OutOfLineAllocate(allocation_size, gc_info_index);
 }
 
 inline NormalPageArena* NormalPage::ArenaForNormalPage() const {
   return static_cast<NormalPageArena*>(Arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h