Rename ASSERT* to DCHECK*.

src/spaces-inl.h

 // Copyright 2011 the V8 project 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 V8_SPACES_INL_H_
 #define V8_SPACES_INL_H_
 
 #include "src/heap-profiler.h"
 #include "src/isolate.h"
 #include "src/spaces.h"
@@ skipping 22 matching lines @@
       prev_page_(&space->anchor_),
       next_page_(prev_page_->next_page()) { }
 
 
 bool PageIterator::has_next() {
   return next_page_ != &space_->anchor_;
 }
 
 
 Page* PageIterator::next() {
-  ASSERT(has_next());
+  DCHECK(has_next());
   prev_page_ = next_page_;
   next_page_ = next_page_->next_page();
   return prev_page_;
 }
 
 
 // -----------------------------------------------------------------------------
 // NewSpacePageIterator
 
 
@@ skipping 14 matching lines @@
   SemiSpace::AssertValidRange(start, limit);
 }
 
 
 bool NewSpacePageIterator::has_next() {
   return prev_page_ != last_page_;
 }
 
 
 NewSpacePage* NewSpacePageIterator::next() {
-  ASSERT(has_next());
+  DCHECK(has_next());
   prev_page_ = next_page_;
   next_page_ = next_page_->next_page();
   return prev_page_;
 }
 
 
 // -----------------------------------------------------------------------------
 // HeapObjectIterator
 HeapObject* HeapObjectIterator::FromCurrentPage() {
   while (cur_addr_ != cur_end_) {
     if (cur_addr_ == space_->top() && cur_addr_ != space_->limit()) {
       cur_addr_ = space_->limit();
       continue;
     }
     HeapObject* obj = HeapObject::FromAddress(cur_addr_);
     int obj_size = (size_func_ == NULL) ? obj->Size() : size_func_(obj);
     cur_addr_ += obj_size;
-    ASSERT(cur_addr_ <= cur_end_);
+    DCHECK(cur_addr_ <= cur_end_);
     if (!obj->IsFiller()) {
-      ASSERT_OBJECT_SIZE(obj_size);
+      DCHECK_OBJECT_SIZE(obj_size);
       return obj;
     }
   }
   return NULL;
 }
 
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
@@ skipping 26 matching lines @@
 #endif
 
 
 // --------------------------------------------------------------------------
 // PagedSpace
 Page* Page::Initialize(Heap* heap,
                        MemoryChunk* chunk,
                        Executability executable,
                        PagedSpace* owner) {
   Page* page = reinterpret_cast<Page*>(chunk);
-  ASSERT(page->area_size() <= kMaxRegularHeapObjectSize);
-  ASSERT(chunk->owner() == owner);
+  DCHECK(page->area_size() <= kMaxRegularHeapObjectSize);
+  DCHECK(chunk->owner() == owner);
   owner->IncreaseCapacity(page->area_size());
   owner->Free(page->area_start(), page->area_size());
 
   heap->incremental_marking()->SetOldSpacePageFlags(chunk);
 
   return page;
 }
 
 
 bool PagedSpace::Contains(Address addr) {
@@ skipping 49 matching lines @@
 
 
 PointerChunkIterator::PointerChunkIterator(Heap* heap)
     : state_(kOldPointerState),
       old_pointer_iterator_(heap->old_pointer_space()),
       map_iterator_(heap->map_space()),
       lo_iterator_(heap->lo_space()) { }
 
 
 Page* Page::next_page() {
-  ASSERT(next_chunk()->owner() == owner());
+  DCHECK(next_chunk()->owner() == owner());
   return static_cast<Page*>(next_chunk());
 }
 
 
 Page* Page::prev_page() {
-  ASSERT(prev_chunk()->owner() == owner());
+  DCHECK(prev_chunk()->owner() == owner());
   return static_cast<Page*>(prev_chunk());
 }
 
 
 void Page::set_next_page(Page* page) {
-  ASSERT(page->owner() == owner());
+  DCHECK(page->owner() == owner());
   set_next_chunk(page);
 }
 
 
 void Page::set_prev_page(Page* page) {
-  ASSERT(page->owner() == owner());
+  DCHECK(page->owner() == owner());
   set_prev_chunk(page);
 }
 
 
 // Try linear allocation in the page of alloc_info's allocation top.  Does
 // not contain slow case logic (e.g. move to the next page or try free list
 // allocation) so it can be used by all the allocation functions and for all
 // the paged spaces.
 HeapObject* PagedSpace::AllocateLinearly(int size_in_bytes) {
   Address current_top = allocation_info_.top();
@@ skipping 33 matching lines @@
 
 AllocationResult NewSpace::AllocateRaw(int size_in_bytes) {
   Address old_top = allocation_info_.top();
 
   if (allocation_info_.limit() - old_top < size_in_bytes) {
     return SlowAllocateRaw(size_in_bytes);
   }
 
   HeapObject* obj = HeapObject::FromAddress(old_top);
   allocation_info_.set_top(allocation_info_.top() + size_in_bytes);
-  ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
+  DCHECK_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
   return obj;
 }
 
 
 LargePage* LargePage::Initialize(Heap* heap, MemoryChunk* chunk) {
   heap->incremental_marking()->SetOldSpacePageFlags(chunk);
   return static_cast<LargePage*>(chunk);
 }
 
 
 intptr_t LargeObjectSpace::Available() {
   return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   Map* map = object->map();
   Heap* heap = object->GetHeap();
   return map == heap->raw_unchecked_free_space_map()
       || map == heap->raw_unchecked_one_pointer_filler_map()
       || map == heap->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_