Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/heap

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

 /*
  * 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 361 matching lines @@
                                     MovingObjectCallback,
                                     void* callback_data);
 
   BlinkGC::GCReason LastGCReason() { return last_gc_reason_; }
   RegionTree* GetRegionTree() { return region_tree_.get(); }
 
   static inline size_t AllocationSizeFromSize(size_t size) {
     // Add space for header.
     size_t allocation_size = size + sizeof(HeapObjectHeader);
     // The allocation size calculation can overflow for large sizes.
-    RELEASE_ASSERT(allocation_size > size);
+    CHECK_GT(allocation_size, size);
     // Align size with allocation granularity.
     allocation_size = (allocation_size + kAllocationMask) & ~kAllocationMask;
     return allocation_size;
   }
   static Address AllocateOnArenaIndex(ThreadState*,
                                       size_t,
                                       int arena_index,
                                       size_t gc_info_index,
                                       const char* type_name);
   template <typename T>
@@ skipping 93 matching lines @@
   WTF_MAKE_NONCOPYABLE(GarbageCollected);
 
   // For now direct allocation of arrays on the heap is not allowed.
   void* operator new[](size_t size);
 
 #if OS(WIN) && COMPILER(MSVC)
   // Due to some quirkiness in the MSVC compiler we have to provide
   // the delete[] operator in the GarbageCollected subclasses as it
   // is called when a class is exported in a DLL.
  protected:
-  void operator delete[](void* p) { ASSERT_NOT_REACHED(); }
+  void operator delete[](void* p) { NOTREACHED(); }
 #else
   void operator delete[](void* p);
 #endif
 
  public:
   using GarbageCollectedType = T;
 
   void* operator new(size_t size) {
     return AllocateObject(size, IsEagerlyFinalizedType<T>::value);
   }
 
   static void* AllocateObject(size_t size, bool eagerly_sweep) {
     return ThreadHeap::Allocate<T>(size, eagerly_sweep);
   }
 
-  void operator delete(void* p) { ASSERT_NOT_REACHED(); }
+  void operator delete(void* p) { NOTREACHED(); }
 
  protected:
   GarbageCollected() {}
 };
 
 // Assigning class types to their arenas.
 //
 // We use sized arenas for most 'normal' objects to improve memory locality.
 // It seems that the same type of objects are likely to be accessed together,
 // which means that we want to group objects by type. That's one reason
@@ skipping 143 matching lines @@
   T** cell = reinterpret_cast<T**>(object);
   if (*cell && !ObjectAliveTrait<T>::IsHeapObjectAlive(*cell))
     *cell = nullptr;
 }
 
 }  // namespace blink
 
 #include "platform/heap/VisitorImpl.h"
 
 #endif  // Heap_h