Replace ASSERT with DHCECK_op in platform/heap

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 283 matching lines @@
   // such a reference.
   template <typename T>
   NO_SANITIZE_ADDRESS static bool WillObjectBeLazilySwept(
       const T* object_pointer) {
     static_assert(IsGarbageCollectedType<T>::value,
                   "only objects deriving from GarbageCollected can be used.");
     BasePage* page = PageFromObject(object_pointer);
     // 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*>(object_pointer)))
       return false;
 
     if (page->IsLargeObjectPage())
       return true;
 
     // If the object is unmarked, it may be on the page currently being
@@ skipping 97 matching lines @@
   void FlushHeapDoesNotContainCache();
 
   PagePool* GetFreePagePool() { return free_page_pool_.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 gc_info_index) {
-    ASSERT(gc_info_index >= 1);
-    ASSERT(gc_info_index < GCInfoTable::kMaxIndex);
-    ASSERT(g_gc_info_table);
+    DCHECK_GE(gc_info_index, 1u);
+    DCHECK(gc_info_index < GCInfoTable::kMaxIndex);

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

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

+    DCHECK(g_gc_info_table);
     const GCInfo* info = g_gc_info_table[gc_info_index];
-    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 128 matching lines @@
  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 verify_eager_finalization_; \
                                                       \
  public:                                              \
   typedef int IsEagerlyFinalizedMarker
 #else
 #define EAGERLY_FINALIZE() \
  public:                   \
   typedef int IsEagerlyFinalizedMarker
 #endif
 
 inline Address ThreadHeap::AllocateOnArenaIndex(ThreadState* state,
                                                 size_t size,
                                                 int arena_index,
                                                 size_t gc_info_index,
                                                 const char* type_name) {
-  ASSERT(state->IsAllocationAllowed());
-  ASSERT(arena_index != BlinkGC::kLargeObjectArenaIndex);
+  DCHECK(state->IsAllocationAllowed());
+  DCHECK_NE(arena_index, BlinkGC::kLargeObjectArenaIndex);
   NormalPageArena* arena =
       static_cast<NormalPageArena*>(state->Arena(arena_index));
   Address address =
       arena->AllocateObject(AllocationSizeFromSize(size), gc_info_index);
   HeapAllocHooks::AllocationHookIfEnabled(address, size, type_name);
   return address;
 }
 
 template <typename T>
 Address ThreadHeap::Allocate(size_t size, bool eagerly_sweep) {
@@ skipping 13 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>::kAffinity>::GetState();
   HeapObjectHeader* previous_header = HeapObjectHeader::FromPayload(previous);
   BasePage* page = PageFromObject(previous_header);
-  ASSERT(page);
+  DCHECK(page);
 
   // Determine arena index of new allocation.
   int arena_index;
   if (size >= kLargeObjectSizeThreshold) {
     arena_index = BlinkGC::kLargeObjectArenaIndex;
   } else {
     arena_index = page->Arena()->ArenaIndex();
     if (IsNormalArenaIndex(arena_index) ||
         arena_index == BlinkGC::kLargeObjectArenaIndex)
       arena_index = ArenaIndexForObjectSize(size);
   }
 
   size_t gc_info_index = GCInfoTrait<T>::Index();
   // TODO(haraken): We don't support reallocate() for finalizable objects.
-  ASSERT(!ThreadHeap::GcInfo(previous_header->GcInfoIndex())->HasFinalizer());
-  ASSERT(previous_header->GcInfoIndex() == gc_info_index);
+  DCHECK(!ThreadHeap::GcInfo(previous_header->GcInfoIndex())->HasFinalizer());
+  DCHECK_EQ(previous_header->GcInfoIndex(), gc_info_index);
   HeapAllocHooks::FreeHookIfEnabled(static_cast<Address>(previous));
   Address address;
   if (arena_index == BlinkGC::kLargeObjectArenaIndex) {
     address = page->Arena()->AllocateLargeObject(AllocationSizeFromSize(size),
                                                  gc_info_index);
   } else {
     const char* type_name = WTF_HEAP_PROFILER_TYPE_NAME(T);
     address = ThreadHeap::AllocateOnArenaIndex(state, size, arena_index,
                                                gc_info_index, type_name);
   }
   size_t copy_size = previous_header->PayloadSize();
   if (copy_size > size)
     copy_size = size;
   memcpy(address, previous, copy_size);
   return address;
 }
 
 template <typename T>
 void Visitor::HandleWeakCell(Visitor* self, void* object) {
   T** cell = reinterpret_cast<T**>(object);
   if (*cell && !ObjectAliveTrait<T>::IsHeapObjectAlive(*cell))
     *cell = nullptr;
 }
 
 }  // namespace blink
 
 #include "platform/heap/VisitorImpl.h"
 
 #endif  // Heap_h