Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/heap

third_party/WebKit/Source/platform/heap/HeapPage.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 228 matching lines @@
   for (BasePage* page = first_unswept_page_; page; page = page->Next())
     page->PoisonUnmarkedObjects();
 }
 #endif
 
 Address BaseArena::LazySweep(size_t allocation_size, size_t gc_info_index) {
   // If there are no pages to be swept, return immediately.
   if (!first_unswept_page_)
     return nullptr;
 
-  RELEASE_ASSERT(GetThreadState()->IsSweepingInProgress());
+  CHECK(GetThreadState()->IsSweepingInProgress());
 
   // lazySweepPages() can be called recursively if finalizers invoked in
   // page->sweep() allocate memory and the allocation triggers
   // lazySweepPages(). This check prevents the sweeping from being executed
   // recursively.
   if (GetThreadState()->SweepForbidden())
     return nullptr;
 
   TRACE_EVENT0("blink_gc", "BaseArena::lazySweepPages");
   ThreadState::SweepForbiddenScope sweep_forbidden(GetThreadState());
@@ skipping 22 matching lines @@
   }
 }
 
 bool BaseArena::LazySweepWithDeadline(double deadline_seconds) {
   // It might be heavy to call
   // Platform::current()->monotonicallyIncreasingTimeSeconds() per page (i.e.,
   // 128 KB sweep or one LargeObject sweep), so we check the deadline per 10
   // pages.
   static const int kDeadlineCheckInterval = 10;
 
-  RELEASE_ASSERT(GetThreadState()->IsSweepingInProgress());
+  CHECK(GetThreadState()->IsSweepingInProgress());
   ASSERT(GetThreadState()->SweepForbidden());
   ASSERT(!GetThreadState()->IsMainThread() ||
          ScriptForbiddenScope::IsScriptForbidden());
 
   NormalPageArena* normal_arena = nullptr;
   if (first_unswept_page_ && !first_unswept_page_->IsLargeObjectPage()) {
     // Mark this NormalPageArena as being lazily swept.
     NormalPage* normal_page =
         reinterpret_cast<NormalPage*>(first_unswept_page_);
     normal_arena = normal_page->ArenaForNormalPage();
@@ skipping 13 matching lines @@
     }
     page_count++;
   }
   ThreadHeap::ReportMemoryUsageForTracing();
   if (normal_arena)
     normal_arena->SetIsLazySweeping(false);
   return true;
 }
 
 void BaseArena::CompleteSweep() {
-  RELEASE_ASSERT(GetThreadState()->IsSweepingInProgress());
+  CHECK(GetThreadState()->IsSweepingInProgress());
   ASSERT(GetThreadState()->SweepForbidden());
   ASSERT(!GetThreadState()->IsMainThread() ||
          ScriptForbiddenScope::IsScriptForbidden());
 
   while (first_unswept_page_) {
     SweepUnsweptPage();
   }
   ThreadHeap::ReportMemoryUsageForTracing();
 }
 
@@ skipping 278 matching lines @@
     for (size_t i = 0; i < kBlinkPagesPerRegion; ++i) {
       PageMemory* memory = PageMemory::SetupPageMemoryInRegion(
           region, i * kBlinkPageSize, BlinkPagePayloadSize());
       // Take the first possible page ensuring that this thread actually
       // gets a page and add the rest to the page pool.
       if (!page_memory) {
         bool result = memory->Commit();
         // If you hit the ASSERT, it will mean that you're hitting
         // the limit of the number of mmapped regions OS can support
         // (e.g., /proc/sys/vm/max_map_count in Linux).
-        RELEASE_ASSERT(result);
+        CHECK(result);
         page_memory = memory;
       } else {
         GetThreadState()->Heap().GetFreePagePool()->Add(ArenaIndex(), memory);
       }
     }
   }
   NormalPage* page =
       new (page_memory->WritableStart()) NormalPage(page_memory, this);
   page->Link(&first_page_);
 
@@ skipping 270 matching lines @@
   GetThreadState()->CompleteSweep();
 
   // 7. Check if we should trigger a GC.
   GetThreadState()->ScheduleGCIfNeeded();
 
   // 8. Add a new page to this heap.
   AllocatePage();
 
   // 9. Try to allocate from a free list. This allocation must succeed.
   result = AllocateFromFreeList(allocation_size, gc_info_index);
-  RELEASE_ASSERT(result);
+  CHECK(result);
   return result;
 }
 
 Address NormalPageArena::AllocateFromFreeList(size_t allocation_size,
                                               size_t gc_info_index) {
   // Try reusing a block from the largest bin. The underlying reasoning
   // being that we want to amortize this slow allocation call by carving
   // off as a large a free block as possible in one go; a block that will
   // service this block and let following allocations be serviced quickly
   // by bump allocation.
@@ skipping 894 matching lines @@
 
   has_entries_ = true;
   size_t index = GetHash(address);
   ASSERT(!(index & 1));
   Address cache_page = RoundToBlinkPageStart(address);
   entries_[index + 1] = entries_[index];
   entries_[index] = cache_page;
 }
 
 }  // namespace blink