Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/ThreadState.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 110 matching lines @@
       invalidate_dead_objects_in_wrappers_marking_deque_(nullptr),
 #if defined(ADDRESS_SANITIZER)
       asan_fake_stack_(__asan_get_current_fake_stack()),
 #endif
 #if defined(LEAK_SANITIZER)
       m_disabledStaticPersistentsRegistration(0),
 #endif
       allocated_object_size_(0),
       marked_object_size_(0),
       reported_memory_to_v8_(0) {
-  ASSERT(CheckThread());
-  ASSERT(!**thread_specific_);
+  DCHECK(CheckThread());
+  DCHECK(!**thread_specific_);
   **thread_specific_ = this;
 
   heap_ = WTF::WrapUnique(new ThreadHeap(this));
 
   for (int arena_index = 0; arena_index < BlinkGC::kLargeObjectArenaIndex;
        arena_index++)
     arenas_[arena_index] = new NormalPageArena(this, arena_index);
   arenas_[BlinkGC::kLargeObjectArenaIndex] =
       new LargeObjectArena(this, BlinkGC::kLargeObjectArenaIndex);
 
   likely_to_be_promptly_freed_ =
       WrapArrayUnique(new int[kLikelyToBePromptlyFreedArraySize]);
   ClearArenaAges();
 }
 
 ThreadState::~ThreadState() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   if (IsMainThread())
     DCHECK_EQ(Heap().HeapStats().AllocatedSpace(), 0u);
   CHECK(GcState() == ThreadState::kNoGCScheduled);
 
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     delete arenas_[i];
 
   **thread_specific_ = nullptr;
 }
 
 void ThreadState::AttachMainThread() {
   thread_specific_ = new WTF::ThreadSpecific<ThreadState*>();
   new (main_thread_state_storage_) ThreadState();
 }
 
 void ThreadState::AttachCurrentThread() {
   new ThreadState();
 }
 
 void ThreadState::DetachCurrentThread() {
   ThreadState* state = Current();
   state->RunTerminationGC();
   delete state;
 }
 
 void ThreadState::RemoveAllPages() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     arenas_[i]->RemoveAllPages();
 }
 
 void ThreadState::RunTerminationGC() {
   if (IsMainThread()) {
     RemoveAllPages();
     return;
   }
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
 
   // Finish sweeping.
   CompleteSweep();
 
   ReleaseStaticPersistentNodes();
 
   ProcessHeap::GetCrossThreadPersistentRegion()
       .PrepareForThreadStateTermination(this);
 
   // Do thread local GC's as long as the count of thread local Persistents
   // changes and is above zero.
   int old_count = -1;
   int current_count = GetPersistentRegion()->NumberOfPersistents();
-  ASSERT(current_count >= 0);
+  DCHECK_GE(current_count, 0);
   while (current_count != old_count) {
     CollectGarbage(BlinkGC::kNoHeapPointersOnStack, BlinkGC::kGCWithSweep,
                    BlinkGC::kThreadTerminationGC);
     // Release the thread-local static persistents that were
     // instantiated while running the termination GC.
     ReleaseStaticPersistentNodes();
     old_count = current_count;
     current_count = GetPersistentRegion()->NumberOfPersistents();
   }
   // We should not have any persistents left when getting to this point,
   // if we have it is probably a bug so adding a debug ASSERT to catch this.
-  ASSERT(!current_count);
+  DCHECK(!current_count);
   // All of pre-finalizers should be consumed.
-  ASSERT(ordered_pre_finalizers_.IsEmpty());
+  DCHECK(ordered_pre_finalizers_.IsEmpty());
   CHECK_EQ(GcState(), kNoGCScheduled);
 
   RemoveAllPages();
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::VisitAsanFakeStackForPointer(Visitor* visitor, Address ptr) {
 #if defined(ADDRESS_SANITIZER)
   Address* start = reinterpret_cast<Address*>(start_of_stack_);
   Address* end = reinterpret_cast<Address*>(end_of_stack_);
@@ skipping 190 matching lines @@
 
 // If we're consuming too much memory, trigger a conservative GC
 // aggressively. This is a safe guard to avoid OOM.
 bool ThreadState::ShouldForceMemoryPressureGC() {
   if (TotalMemorySize() < 300 * 1024 * 1024)
     return false;
   return JudgeGCThreshold(0, 0, 1.5);
 }
 
 void ThreadState::ScheduleV8FollowupGCIfNeeded(BlinkGC::V8GCType gc_type) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   ThreadHeap::ReportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF("ThreadState::scheduleV8FollowupGCIfNeeded (gcType=%s)\n",
            gcType == BlinkGC::V8MajorGC ? "MajorGC" : "MinorGC");
 #endif
 
   if (IsGCForbidden())
     return;
 
   // This completeSweep() will do nothing in common cases since we've
   // called completeSweep() before V8 starts minor/major GCs.
   CompleteSweep();
-  ASSERT(!IsSweepingInProgress());
-  ASSERT(!SweepForbidden());
+  DCHECK(!IsSweepingInProgress());
+  DCHECK(!SweepForbidden());
 
   if ((gc_type == BlinkGC::kV8MajorGC && ShouldForceMemoryPressureGC()) ||
       ShouldScheduleV8FollowupGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled PreciseGC\n");
 #endif
     SchedulePreciseGC();
     return;
   }
   if (gc_type == BlinkGC::kV8MajorGC && ShouldScheduleIdleGC()) {
@@ skipping 12 matching lines @@
   // TODO(haraken): It's a bit too late for a major GC to schedule
   // completeSweep() here, because gcPrologue for a major GC is called
   // not at the point where the major GC started but at the point where
   // the major GC requests object grouping.
   if (gc_type == BlinkGC::kV8MajorGC)
     CompleteSweep();
 }
 
 void ThreadState::SchedulePageNavigationGCIfNeeded(
     float estimated_removal_ratio) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   ThreadHeap::ReportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF(
       "ThreadState::schedulePageNavigationGCIfNeeded "
       "(estimatedRemovalRatio=%.2lf)\n",
       estimatedRemovalRatio);
 #endif
 
   if (IsGCForbidden())
     return;
 
   // Finish on-going lazy sweeping.
   // TODO(haraken): It might not make sense to force completeSweep() for all
   // page navigations.
   CompleteSweep();
-  ASSERT(!IsSweepingInProgress());
-  ASSERT(!SweepForbidden());
+  DCHECK(!IsSweepingInProgress());
+  DCHECK(!SweepForbidden());
 
   if (ShouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled MemoryPressureGC\n");
 #endif
     CollectGarbage(BlinkGC::kHeapPointersOnStack, BlinkGC::kGCWithoutSweep,
                    BlinkGC::kMemoryPressureGC);
     return;
   }
   if (ShouldSchedulePageNavigationGC(estimated_removal_ratio)) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled PageNavigationGC\n");
 #endif
     SchedulePageNavigationGC();
   }
 }
 
 void ThreadState::SchedulePageNavigationGC() {
-  ASSERT(CheckThread());
-  ASSERT(!IsSweepingInProgress());
+  DCHECK(CheckThread());
+  DCHECK(!IsSweepingInProgress());
   SetGCState(kPageNavigationGCScheduled);
 }
 
 void ThreadState::ScheduleGCIfNeeded() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   ThreadHeap::ReportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF("ThreadState::scheduleGCIfNeeded\n");
 #endif
 
   // Allocation is allowed during sweeping, but those allocations should not
   // trigger nested GCs.
   if (IsGCForbidden())
     return;
 
   if (IsSweepingInProgress())
     return;
-  ASSERT(!SweepForbidden());
+  DCHECK(!SweepForbidden());
 
   ReportMemoryToV8();
 
   if (ShouldForceMemoryPressureGC()) {
     CompleteSweep();
     if (ShouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
       dataLogF("Scheduled MemoryPressureGC\n");
 #endif
       CollectGarbage(BlinkGC::kHeapPointersOnStack, BlinkGC::kGCWithoutSweep,
@@ skipping 16 matching lines @@
   if (ShouldScheduleIdleGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled IdleGC\n");
 #endif
     ScheduleIdleGC();
     return;
   }
 }
 
 ThreadState* ThreadState::FromObject(const void* object) {
-  ASSERT(object);
+  DCHECK(object);
   BasePage* page = PageFromObject(object);
-  ASSERT(page);
-  ASSERT(page->Arena());
+  DCHECK(page);
+  DCHECK(page->Arena());
   return page->Arena()->GetThreadState();
 }
 
 void ThreadState::PerformIdleGC(double deadline_seconds) {
-  ASSERT(CheckThread());
-  ASSERT(Platform::Current()->CurrentThread()->Scheduler());
+  DCHECK(CheckThread());
+  DCHECK(Platform::Current()->CurrentThread()->Scheduler());
 
   if (GcState() != kIdleGCScheduled)
     return;
 
   if (IsGCForbidden()) {
     // If GC is forbidden at this point, try again.
     ScheduleIdleGC();
     return;
   }
 
@@ skipping 11 matching lines @@
   }
 
   TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds",
                idle_delta_in_seconds, "estimatedMarkingTime",
                heap_->HeapStats().EstimatedMarkingTime());
   CollectGarbage(BlinkGC::kNoHeapPointersOnStack, BlinkGC::kGCWithoutSweep,
                  BlinkGC::kIdleGC);
 }
 
 void ThreadState::PerformIdleLazySweep(double deadline_seconds) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
 
   // If we are not in a sweeping phase, there is nothing to do here.
   if (!IsSweepingInProgress())
     return;
 
   // This check is here to prevent performIdleLazySweep() from being called
   // recursively. I'm not sure if it can happen but it would be safer to have
   // the check just in case.
   if (SweepForbidden())
     return;
@@ skipping 48 matching lines @@
   // Some threads (e.g. PPAPI thread) don't have a scheduler.
   if (!Platform::Current()->CurrentThread()->Scheduler())
     return;
 
   Platform::Current()->CurrentThread()->Scheduler()->PostIdleTask(
       BLINK_FROM_HERE,
       WTF::Bind(&ThreadState::PerformIdleLazySweep, WTF::Unretained(this)));
 }
 
 void ThreadState::SchedulePreciseGC() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   if (IsSweepingInProgress()) {
     SetGCState(kSweepingAndPreciseGCScheduled);
     return;
   }
 
   SetGCState(kPreciseGCScheduled);
 }
 
 namespace {
 
@@ skipping 22 matching lines @@
 
 }  // namespace
 
 #define VERIFY_STATE_TRANSITION(condition) \
   if (UNLIKELY(!(condition)))              \
   UnexpectedGCState(gc_state_)
 
 void ThreadState::SetGCState(GCState gc_state) {
   switch (gc_state) {
     case kNoGCScheduled:
-      ASSERT(CheckThread());
+      DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(gc_state_ == kSweeping ||
                               gc_state_ == kSweepingAndIdleGCScheduled);
       break;
     case kIdleGCScheduled:
     case kPreciseGCScheduled:
     case kFullGCScheduled:
     case kPageNavigationGCScheduled:
-      ASSERT(CheckThread());
+      DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(
           gc_state_ == kNoGCScheduled || gc_state_ == kIdleGCScheduled ||
           gc_state_ == kPreciseGCScheduled || gc_state_ == kFullGCScheduled ||
           gc_state_ == kPageNavigationGCScheduled || gc_state_ == kSweeping ||
           gc_state_ == kSweepingAndIdleGCScheduled ||
           gc_state_ == kSweepingAndPreciseGCScheduled);
       CompleteSweep();
       break;
     case kGCRunning:
-      ASSERT(!IsInGC());
+      DCHECK(!IsInGC());
       VERIFY_STATE_TRANSITION(gc_state_ != kGCRunning);
       break;
     case kSweeping:
       DCHECK(IsInGC());
       ASSERT(CheckThread());
       VERIFY_STATE_TRANSITION(gc_state_ == kGCRunning);
       break;
     case kSweepingAndIdleGCScheduled:
     case kSweepingAndPreciseGCScheduled:
-      ASSERT(CheckThread());
+      DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(gc_state_ == kSweeping ||
                               gc_state_ == kSweepingAndIdleGCScheduled ||
                               gc_state_ == kSweepingAndPreciseGCScheduled);
       break;
     default:
       NOTREACHED();
   }
   gc_state_ = gc_state;
 }
 
 #undef VERIFY_STATE_TRANSITION
 
 void ThreadState::RunScheduledGC(BlinkGC::StackState stack_state) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   if (stack_state != BlinkGC::kNoHeapPointersOnStack)
     return;
 
   // If a safe point is entered while initiating a GC, we clearly do
   // not want to do another as part of that -- the safe point is only
   // entered after checking if a scheduled GC ought to run first.
   // Prevent that from happening by marking GCs as forbidden while
   // one is initiated and later running.
   if (IsGCForbidden())
     return;
@@ skipping 19 matching lines @@
 }
 
 void ThreadState::FlushHeapDoesNotContainCacheIfNeeded() {
   if (should_flush_heap_does_not_contain_cache_) {
     heap_->FlushHeapDoesNotContainCache();
     should_flush_heap_does_not_contain_cache_ = false;
   }
 }
 
 void ThreadState::MakeConsistentForGC() {
-  ASSERT(IsInGC());
+  DCHECK(IsInGC());
   TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForGC");
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     arenas_[i]->MakeConsistentForGC();
 }
 
 void ThreadState::Compact() {
   if (!Heap().Compaction()->IsCompacting())
     return;
 
   SweepForbiddenScope scope(this);
@@ skipping 14 matching lines @@
   // TODO: implement bail out wrt any overall deadline, not compacting
   // the remaining arenas if the time budget has been exceeded.
   Heap().Compaction()->StartThreadCompaction();
   for (int i = BlinkGC::kHashTableArenaIndex; i >= BlinkGC::kVector1ArenaIndex;
        --i)
     static_cast<NormalPageArena*>(arenas_[i])->SweepAndCompact();
   Heap().Compaction()->FinishThreadCompaction();
 }
 
 void ThreadState::MakeConsistentForMutator() {
-  ASSERT(IsInGC());
+  DCHECK(IsInGC());
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     arenas_[i]->MakeConsistentForMutator();
 }
 
 void ThreadState::PreGC() {
   if (isolate_ && perform_cleanup_)
     perform_cleanup_(isolate_);
 
-  ASSERT(!IsInGC());
+  DCHECK(!IsInGC());
   SetGCState(kGCRunning);
   MakeConsistentForGC();
   FlushHeapDoesNotContainCacheIfNeeded();
   ClearArenaAges();
 }
 
 void ThreadState::PostGC(BlinkGC::GCType gc_type) {
   if (invalidate_dead_objects_in_wrappers_marking_deque_)
     invalidate_dead_objects_in_wrappers_marking_deque_(isolate_);
 
@@ skipping 79 matching lines @@
   // that would be fine.
   ProcessHeap::GetCrossThreadPersistentRegion()
       .UnpoisonCrossThreadPersistents();
 }
 #endif
 
 void ThreadState::EagerSweep() {
 #if defined(ADDRESS_SANITIZER)
   PoisonEagerArena();
 #endif
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   // Some objects need to be finalized promptly and cannot be handled
   // by lazy sweeping. Keep those in a designated heap and sweep it
   // eagerly.
-  ASSERT(IsSweepingInProgress());
+  DCHECK(IsSweepingInProgress());
 
   // Mirroring the completeSweep() condition; see its comment.
   if (SweepForbidden())
     return;
 
   SweepForbiddenScope scope(this);
   ScriptForbiddenIfMainThreadScope script_forbidden_scope;
 
   double start_time = WTF::CurrentTimeMS();
   arenas_[BlinkGC::kEagerSweepArenaIndex]->CompleteSweep();
   AccumulateSweepingTime(WTF::CurrentTimeMS() - start_time);
 }
 
 void ThreadState::CompleteSweep() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   // If we are not in a sweeping phase, there is nothing to do here.
   if (!IsSweepingInProgress())
     return;
 
   // completeSweep() can be called recursively if finalizers can allocate
   // memory and the allocation triggers completeSweep(). This check prevents
   // the sweeping from being executed recursively.
   if (SweepForbidden())
     return;
 
@@ skipping 14 matching lines @@
   if (IsMainThread()) {
     DEFINE_STATIC_LOCAL(CustomCountHistogram, complete_sweep_histogram,
                         ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
     complete_sweep_histogram.Count(time_for_complete_sweep);
   }
 
   PostSweep();
 }
 
 void ThreadState::PostSweep() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   ThreadHeap::ReportMemoryUsageForTracing();
 
   if (IsMainThread()) {
     double collection_rate = 0;
     if (heap_->HeapStats().ObjectSizeAtLastGC() > 0)
       collection_rate = 1 - 1.0 * heap_->HeapStats().MarkedObjectSize() /
                                 heap_->HeapStats().ObjectSizeAtLastGC();
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"),
                    "ThreadState::collectionRate",
                    static_cast<int>(100 * collection_rate));
@@ skipping 80 matching lines @@
 }
 
 size_t ThreadState::ObjectPayloadSizeForTesting() {
   size_t object_payload_size = 0;
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     object_payload_size += arenas_[i]->ObjectPayloadSizeForTesting();
   return object_payload_size;
 }
 
 void ThreadState::SafePoint(BlinkGC::StackState stack_state) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   ThreadHeap::ReportMemoryUsageForTracing();
 
   RunScheduledGC(stack_state);
   stack_state_ = BlinkGC::kHeapPointersOnStack;
 }
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with
 // detect_stack_use_after_return=1 then stack marker obtained from
 // SafePointScope will point into a fake stack.  Detect this case by checking if
@@ skipping 24 matching lines @@
 
 static void EnterSafePointAfterPushRegisters(void*,
                                              ThreadState* state,
                                              intptr_t* stack_end) {
   state->RecordStackEnd(stack_end);
   state->CopyStackUntilSafePointScope();
 }
 
 void ThreadState::EnterSafePoint(BlinkGC::StackState stack_state,
                                  void* scope_marker) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
 #ifdef ADDRESS_SANITIZER
   if (stack_state == BlinkGC::kHeapPointersOnStack)
     scope_marker = AdjustScopeMarkerForAdressSanitizer(scope_marker);
 #endif
-  ASSERT(stack_state == BlinkGC::kNoHeapPointersOnStack || scope_marker);
+  DCHECK(stack_state == BlinkGC::kNoHeapPointersOnStack || scope_marker);
   RunScheduledGC(stack_state);
   stack_state_ = stack_state;
   safe_point_scope_marker_ = scope_marker;
   PushAllRegisters(nullptr, this, EnterSafePointAfterPushRegisters);
 }
 
 void ThreadState::LeaveSafePoint() {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   stack_state_ = BlinkGC::kHeapPointersOnStack;
   ClearSafePointScopeMarker();
 }
 
 void ThreadState::ReportMemoryToV8() {
   if (!isolate_)
     return;
 
   size_t current_heap_size = allocated_object_size_ + marked_object_size_;
   int64_t diff = static_cast<int64_t>(current_heap_size) -
@@ skipping 29 matching lines @@
 
   Address* to = reinterpret_cast<Address*>(safe_point_scope_marker_);
   Address* from = reinterpret_cast<Address*>(end_of_stack_);
   CHECK_LT(from, to);
   CHECK_LE(to, reinterpret_cast<Address*>(start_of_stack_));
   size_t slot_count = static_cast<size_t>(to - from);
 // Catch potential performance issues.
 #if defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
   // ASan/LSan use more space on the stack and we therefore
   // increase the allowed stack copying for those builds.
-  ASSERT(slot_count < 2048);
+  DCHECK_LT(slot_count, 2048u);
 #else
-  ASSERT(slot_count < 1024);
+  DCHECK_LT(slot_count, 1024u);
 #endif
 
-  ASSERT(!safe_point_stack_copy_.size());
+  DCHECK(!safe_point_stack_copy_.size());
   safe_point_stack_copy_.Resize(slot_count);
   for (size_t i = 0; i < slot_count; ++i) {
     safe_point_stack_copy_[i] = from[i];
   }
 }
 
 void ThreadState::RegisterStaticPersistentNode(
     PersistentNode* node,
     PersistentClearCallback callback) {
 #if defined(LEAK_SANITIZER)
   if (m_disabledStaticPersistentsRegistration)
     return;
 #endif
 
-  ASSERT(!static_persistents_.Contains(node));
+  DCHECK(!static_persistents_.Contains(node));
   static_persistents_.insert(node, callback);
 }
 
 void ThreadState::ReleaseStaticPersistentNodes() {
   HashMap<PersistentNode*, ThreadState::PersistentClearCallback>
       static_persistents;
   static_persistents.swap(static_persistents_);
 
   PersistentRegion* persistent_region = GetPersistentRegion();
   for (const auto& it : static_persistents)
     persistent_region->ReleasePersistentNode(it.key, it.value);
 }
 
 void ThreadState::FreePersistentNode(PersistentNode* persistent_node) {
   PersistentRegion* persistent_region = GetPersistentRegion();
   persistent_region->FreePersistentNode(persistent_node);
   // Do not allow static persistents to be freed before
   // they're all released in releaseStaticPersistentNodes().
   //
   // There's no fundamental reason why this couldn't be supported,
   // but no known use for it.
-  ASSERT(!static_persistents_.Contains(persistent_node));
+  DCHECK(!static_persistents_.Contains(persistent_node));
 }
 
 #if defined(LEAK_SANITIZER)
 void ThreadState::enterStaticReferenceRegistrationDisabledScope() {
   m_disabledStaticPersistentsRegistration++;
 }
 
 void ThreadState::leaveStaticReferenceRegistrationDisabledScope() {
-  ASSERT(m_disabledStaticPersistentsRegistration);
+  DCHECK(m_disabledStaticPersistentsRegistration);
   m_disabledStaticPersistentsRegistration--;
 }
 #endif
 
 void ThreadState::InvokePreFinalizers() {
-  ASSERT(CheckThread());
-  ASSERT(!SweepForbidden());
+  DCHECK(CheckThread());
+  DCHECK(!SweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
   SweepForbiddenScope sweep_forbidden(this);
   ScriptForbiddenIfMainThreadScope script_forbidden;
   // Pre finalizers may access unmarked objects but are forbidden from
   // ressurecting them.
   ObjectResurrectionForbiddenScope object_resurrection_forbidden(this);
 
   double start_time = WTF::CurrentTimeMS();
   if (!ordered_pre_finalizers_.IsEmpty()) {
@@ skipping 35 matching lines @@
     int end_arena_index) {
   size_t min_arena_age = arena_ages_[begin_arena_index];
   int arena_index_with_min_arena_age = begin_arena_index;
   for (int arena_index = begin_arena_index + 1; arena_index <= end_arena_index;
        arena_index++) {
     if (arena_ages_[arena_index] < min_arena_age) {
       min_arena_age = arena_ages_[arena_index];
       arena_index_with_min_arena_age = arena_index;
     }
   }
-  ASSERT(IsVectorArenaIndex(arena_index_with_min_arena_age));
+  DCHECK(IsVectorArenaIndex(arena_index_with_min_arena_age));
   return arena_index_with_min_arena_age;
 }
 
 BaseArena* ThreadState::ExpandedVectorBackingArena(size_t gc_info_index) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   size_t entry_index = gc_info_index & kLikelyToBePromptlyFreedArrayMask;
   --likely_to_be_promptly_freed_[entry_index];
   int arena_index = vector_backing_arena_index_;
   arena_ages_[arena_index] = ++current_arena_ages_;
   vector_backing_arena_index_ = ArenaIndexOfVectorArenaLeastRecentlyExpanded(
       BlinkGC::kVector1ArenaIndex, BlinkGC::kVector4ArenaIndex);
   return arenas_[arena_index];
 }
 
 void ThreadState::AllocationPointAdjusted(int arena_index) {
   arena_ages_[arena_index] = ++current_arena_ages_;
   if (vector_backing_arena_index_ == arena_index)
     vector_backing_arena_index_ = ArenaIndexOfVectorArenaLeastRecentlyExpanded(
         BlinkGC::kVector1ArenaIndex, BlinkGC::kVector4ArenaIndex);
 }
 
 void ThreadState::PromptlyFreed(size_t gc_info_index) {
-  ASSERT(CheckThread());
+  DCHECK(CheckThread());
   size_t entry_index = gc_info_index & kLikelyToBePromptlyFreedArrayMask;
   // See the comment in vectorBackingArena() for why this is +3.
   likely_to_be_promptly_freed_[entry_index] += 3;
 }
 
 void ThreadState::TakeSnapshot(SnapshotType type) {
-  ASSERT(IsInGC());
+  DCHECK(IsInGC());
 
   // 0 is used as index for freelist entries. Objects are indexed 1 to
   // gcInfoIndex.
   GCSnapshotInfo info(GCInfoTable::GcInfoIndex() + 1);
   String thread_dump_name = String::Format("blink_gc/thread_%lu",
                                            static_cast<unsigned long>(thread_));
   const String heaps_dump_name = thread_dump_name + "/heaps";
   const String classes_dump_name = thread_dump_name + "/classes";
 
   int number_of_heaps_reported = 0;
@@ skipping 21 matching lines @@
   SNAPSHOT_HEAP(EagerSweep);
   SNAPSHOT_HEAP(Vector1);
   SNAPSHOT_HEAP(Vector2);
   SNAPSHOT_HEAP(Vector3);
   SNAPSHOT_HEAP(Vector4);
   SNAPSHOT_HEAP(InlineVector);
   SNAPSHOT_HEAP(HashTable);
   SNAPSHOT_HEAP(LargeObject);
   FOR_EACH_TYPED_ARENA(SNAPSHOT_HEAP);
 
-  ASSERT(number_of_heaps_reported == BlinkGC::kNumberOfArenas);
+  DCHECK_EQ(number_of_heaps_reported, BlinkGC::kNumberOfArenas);
 
 #undef SNAPSHOT_HEAP
 
   if (type == SnapshotType::kFreelistSnapshot)
     return;
 
   size_t total_live_count = 0;
   size_t total_dead_count = 0;
   size_t total_live_size = 0;
   size_t total_dead_size = 0;
@@ skipping 153 matching lines @@
     CollectGarbage(BlinkGC::kNoHeapPointersOnStack, BlinkGC::kGCWithSweep,
                    BlinkGC::kForcedGC);
     size_t live_objects = Heap().HeapStats().MarkedObjectSize();
     if (live_objects == previous_live_objects)
       break;
     previous_live_objects = live_objects;
   }
 }
 
 }  // namespace blink