Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT 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 194 matching lines @@
     // 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);
   // All of pre-finalizers should be consumed.
   ASSERT(ordered_pre_finalizers_.IsEmpty());
-  RELEASE_ASSERT(GcState() == kNoGCScheduled);
+  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_);
   Address* fake_frame_start = nullptr;
@@ skipping 468 matching lines @@
   switch (gc_state) {
     UNEXPECTED_GCSTATE(kNoGCScheduled);
     UNEXPECTED_GCSTATE(kIdleGCScheduled);
     UNEXPECTED_GCSTATE(kPreciseGCScheduled);
     UNEXPECTED_GCSTATE(kFullGCScheduled);
     UNEXPECTED_GCSTATE(kGCRunning);
     UNEXPECTED_GCSTATE(kSweeping);
     UNEXPECTED_GCSTATE(kSweepingAndIdleGCScheduled);
     UNEXPECTED_GCSTATE(kSweepingAndPreciseGCScheduled);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return;
   }
 }
 
 #undef UNEXPECTED_GCSTATE
 
 }  // namespace
 
 #define VERIFY_STATE_TRANSITION(condition) \
   if (UNLIKELY(!(condition)))              \
@@ skipping 29 matching lines @@
       VERIFY_STATE_TRANSITION(gc_state_ == kGCRunning);
       break;
     case kSweepingAndIdleGCScheduled:
     case kSweepingAndPreciseGCScheduled:
       ASSERT(CheckThread());
       VERIFY_STATE_TRANSITION(gc_state_ == kSweeping ||
                               gc_state_ == kSweepingAndIdleGCScheduled ||
                               gc_state_ == kSweepingAndPreciseGCScheduled);
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
   gc_state_ = gc_state;
 }
 
 #undef VERIFY_STATE_TRANSITION
 
 void ThreadState::RunScheduledGC(BlinkGC::StackState stack_state) {
   ASSERT(CheckThread());
   if (stack_state != BlinkGC::kNoHeapPointersOnStack)
     return;
@@ skipping 295 matching lines @@
       SetGCState(kNoGCScheduled);
       break;
     case kSweepingAndPreciseGCScheduled:
       SetGCState(kPreciseGCScheduled);
       break;
     case kSweepingAndIdleGCScheduled:
       SetGCState(kNoGCScheduled);
       ScheduleIdleGC();
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 #if DCHECK_IS_ON()
 BasePage* ThreadState::FindPageFromAddress(Address address) {
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i) {
     if (BasePage* page = arenas_[i]->FindPageFromAddress(address))
       return page;
   }
   return nullptr;
@@ skipping 28 matching lines @@
 // 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
 // it falls in between current stack frame and stack start and use an arbitrary
 // high enough value for it.  Don't adjust stack marker in any other case to
 // match behavior of code running without AddressSanitizer.
 NO_SANITIZE_ADDRESS static void* AdjustScopeMarkerForAdressSanitizer(
     void* scope_marker) {
   Address start = reinterpret_cast<Address>(WTF::GetStackStart());
   Address end = reinterpret_cast<Address>(&start);
-  RELEASE_ASSERT(end < start);
+  CHECK_LT(end, start);
 
   if (end <= scope_marker && scope_marker < start)
     return scope_marker;
 
   // 256 is as good an approximation as any else.
   const size_t kBytesToCopy = sizeof(Address) * 256;
   if (static_cast<size_t>(start - end) < kBytesToCopy)
     return start;
 
   return end + kBytesToCopy;
@@ skipping 62 matching lines @@
   heap_->HeapStats().IncreaseMarkedObjectSize(delta);
 }
 
 void ThreadState::CopyStackUntilSafePointScope() {
   if (!safe_point_scope_marker_ ||
       stack_state_ == BlinkGC::kNoHeapPointersOnStack)
     return;
 
   Address* to = reinterpret_cast<Address*>(safe_point_scope_marker_);
   Address* from = reinterpret_cast<Address*>(end_of_stack_);
-  RELEASE_ASSERT(from < to);
-  RELEASE_ASSERT(to <= reinterpret_cast<Address*>(start_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);
 #else
   ASSERT(slot_count < 1024);
 #endif
 
@@ skipping 153 matching lines @@
     switch (type) {                                                       \
       case SnapshotType::kHeapSnapshot:                                   \
         arenas_[BlinkGC::k##ArenaType##ArenaIndex]->TakeSnapshot(         \
             heaps_dump_name + "/" #ArenaType, info);                      \
         break;                                                            \
       case SnapshotType::kFreelistSnapshot:                               \
         arenas_[BlinkGC::k##ArenaType##ArenaIndex]->TakeFreelistSnapshot( \
             heaps_dump_name + "/" #ArenaType);                            \
         break;                                                            \
       default:                                                            \
-        ASSERT_NOT_REACHED();                                             \
+        NOTREACHED();                                                     \
     }                                                                     \
   }
 
   SNAPSHOT_HEAP(NormalPage1);
   SNAPSHOT_HEAP(NormalPage2);
   SNAPSHOT_HEAP(NormalPage3);
   SNAPSHOT_HEAP(NormalPage4);
   SNAPSHOT_HEAP(EagerSweep);
   SNAPSHOT_HEAP(Vector1);
   SNAPSHOT_HEAP(Vector2);
@@ skipping 39 matching lines @@
           ->CreateMemoryAllocatorDumpForCurrentGC(classes_dump_name);
   BlinkGCMemoryDumpProvider::Instance()
       ->CurrentProcessMemoryDump()
       ->AddOwnershipEdge(classes_dump->guid(), heaps_dump->guid());
 }
 
 void ThreadState::CollectGarbage(BlinkGC::StackState stack_state,
                                  BlinkGC::GCType gc_type,
                                  BlinkGC::GCReason reason) {
   // Nested collectGarbage() invocations aren't supported.
-  RELEASE_ASSERT(!IsGCForbidden());
+  CHECK(!IsGCForbidden());
   CompleteSweep();
 
   GCForbiddenScope gc_forbidden_scope(this);
 
   {
     // Access to the CrossThreadPersistentRegion has to be prevented while in
     // the marking phase because otherwise other threads may allocate or free
     // PersistentNodes and we can't handle that.
     CrossThreadPersistentRegion::LockScope persistent_lock(
         ProcessHeap::GetCrossThreadPersistentRegion());
@@ skipping 111 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