Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/Heap.cpp

 /*
  * 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 153 matching lines @@
 ThreadHeap::~ThreadHeap() {
 }
 
 #if DCHECK_IS_ON()
 BasePage* ThreadHeap::FindPageFromAddress(Address address) {
   return thread_state_->FindPageFromAddress(address);
 }
 #endif
 
 Address ThreadHeap::CheckAndMarkPointer(Visitor* visitor, Address address) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
 #if !DCHECK_IS_ON()
   if (heap_does_not_contain_cache_->Lookup(address))
     return nullptr;
 #endif
 
   if (BasePage* page = LookupPageForAddress(address)) {
-    ASSERT(page->Contains(address));
-    ASSERT(!heap_does_not_contain_cache_->Lookup(address));
+#if DCHECK_IS_ON()
+    DCHECK(page->Contains(address));
+#endif
+    DCHECK(!heap_does_not_contain_cache_->Lookup(address));
     DCHECK(&visitor->Heap() == &page->Arena()->GetThreadState()->Heap());
     page->CheckAndMarkPointer(visitor, address);
     return address;
   }
 
 #if !DCHECK_IS_ON()
   heap_does_not_contain_cache_->AddEntry(address);
 #else
   if (!heap_does_not_contain_cache_->Lookup(address))
     heap_does_not_contain_cache_->AddEntry(address);
@@ skipping 18 matching lines @@
     page->CheckAndMarkPointer(visitor, address, callback);
     return address;
   }
   if (!heap_does_not_contain_cache_->Lookup(address))
     heap_does_not_contain_cache_->AddEntry(address);
   return nullptr;
 }
 #endif
 
 void ThreadHeap::PushTraceCallback(void* object, TraceCallback callback) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   CallbackStack::Item* slot = marking_stack_->AllocateEntry();
   *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadHeap::PopAndInvokeTraceCallback(Visitor* visitor) {
   CallbackStack::Item* item = marking_stack_->Pop();
   if (!item)
     return false;
   item->Call(visitor);
   return true;
 }
 
 void ThreadHeap::PushPostMarkingCallback(void* object, TraceCallback callback) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   CallbackStack::Item* slot = post_marking_callback_stack_->AllocateEntry();
   *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadHeap::PopAndInvokePostMarkingCallback(Visitor* visitor) {
   if (CallbackStack::Item* item = post_marking_callback_stack_->Pop()) {
     item->Call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::PushWeakCallback(void* closure, WeakCallback callback) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   CallbackStack::Item* slot = weak_callback_stack_->AllocateEntry();
   *slot = CallbackStack::Item(closure, callback);
 }
 
 bool ThreadHeap::PopAndInvokeWeakCallback(Visitor* visitor) {
   if (CallbackStack::Item* item = weak_callback_stack_->Pop()) {
     item->Call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::RegisterWeakTable(void* table,
                                    EphemeronCallback iteration_callback,
                                    EphemeronCallback iteration_done_callback) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   CallbackStack::Item* slot = ephemeron_stack_->AllocateEntry();
   *slot = CallbackStack::Item(table, iteration_callback);
 
   // Register a post-marking callback to tell the tables that
   // ephemeron iteration is complete.
   PushPostMarkingCallback(table, iteration_done_callback);
 }
 
 #if DCHECK_IS_ON()
 bool ThreadHeap::WeakTableRegistered(const void* table) {
-  ASSERT(ephemeron_stack_);
+  DCHECK(ephemeron_stack_);
   return ephemeron_stack_->HasCallbackForObject(table);
 }
 #endif
 
 void ThreadHeap::CommitCallbackStacks() {
   marking_stack_->Commit();
   post_marking_callback_stack_->Commit();
   weak_callback_stack_->Commit();
   ephemeron_stack_->Commit();
 }
@@ skipping 53 matching lines @@
   // 1. the ephemeronIterationDone callbacks on weak tables to do cleanup
   //    (specifically to clear the queued bits for weak hash tables), and
   // 2. the markNoTracing callbacks on collection backings to mark them
   //    if they are only reachable from their front objects.
   while (PopAndInvokePostMarkingCallback(visitor)) {
   }
 
   // Post-marking callbacks should not trace any objects and
   // therefore the marking stack should be empty after the
   // post-marking callbacks.
-  ASSERT(marking_stack_->IsEmpty());
+  DCHECK(marking_stack_->IsEmpty());
 }
 
 void ThreadHeap::WeakProcessing(Visitor* visitor) {
   TRACE_EVENT0("blink_gc", "ThreadHeap::weakProcessing");
   double start_time = WTF::CurrentTimeMS();
 
   // Weak processing may access unmarked objects but are forbidden from
   // ressurecting them.
   ThreadState::ObjectResurrectionForbiddenScope object_resurrection_forbidden(
       ThreadState::Current());
 
   // Call weak callbacks on objects that may now be pointing to dead objects.
   while (PopAndInvokeWeakCallback(visitor)) {
   }
 
   // It is not permitted to trace pointers of live objects in the weak
   // callback phase, so the marking stack should still be empty here.
-  ASSERT(marking_stack_->IsEmpty());
+  DCHECK(marking_stack_->IsEmpty());
 
   double time_for_weak_processing = WTF::CurrentTimeMS() - start_time;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, weak_processing_time_histogram,
       new CustomCountHistogram("BlinkGC.TimeForGlobalWeakProcessing", 1,
                                10 * 1000, 50));
   weak_processing_time_histogram.Count(time_for_weak_processing);
 }
 
 void ThreadHeap::ReportMemoryUsageHistogram() {
@@ skipping 90 matching lines @@
   size_t object_payload_size = 0;
   thread_state_->SetGCState(ThreadState::kGCRunning);
   thread_state_->MakeConsistentForGC();
   object_payload_size += thread_state_->ObjectPayloadSizeForTesting();
   thread_state_->SetGCState(ThreadState::kSweeping);
   thread_state_->SetGCState(ThreadState::kNoGCScheduled);
   return object_payload_size;
 }
 
 void ThreadHeap::VisitPersistentRoots(Visitor* visitor) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitPersistentRoots");
   ProcessHeap::GetCrossThreadPersistentRegion().TracePersistentNodes(visitor);
 
   thread_state_->VisitPersistents(visitor);
 }
 
 void ThreadHeap::VisitStackRoots(Visitor* visitor) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitStackRoots");
   thread_state_->VisitStack(visitor);
 }
 
 BasePage* ThreadHeap::LookupPageForAddress(Address address) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
   if (PageMemoryRegion* region = region_tree_->Lookup(address)) {
     return region->PageFromAddress(address);
   }
   return nullptr;
 }
 
 void ThreadHeap::ResetHeapCounters() {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   ThreadHeap::ReportMemoryUsageForTracing();
 
   ProcessHeap::DecreaseTotalAllocatedObjectSize(stats_.AllocatedObjectSize());
   ProcessHeap::DecreaseTotalMarkedObjectSize(stats_.MarkedObjectSize());
 
   stats_.Reset();
   thread_state_->ResetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::main_thread_heap_ = nullptr;
 
 }  // namespace blink