Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/wtf

third_party/WebKit/Source/platform/wtf/StackUtil.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/wtf/StackUtil.h"
 
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Threading.h"
 #include "platform/wtf/WTFThreadData.h"
 
@@ skipping 27 matching lines @@
 #if OS(FREEBSD)
   pthread_attr_init(&attr);
   error = pthread_attr_get_np(pthread_self(), &attr);
 #else
   error = pthread_getattr_np(pthread_self(), &attr);
 #endif
   if (!error) {
     void* base;
     size_t size;
     error = pthread_attr_getstack(&attr, &base, &size);
-    RELEASE_ASSERT(!error);
+    CHECK(!error);
     pthread_attr_destroy(&attr);
     return size;
   }
 #if OS(FREEBSD)
   pthread_attr_destroy(&attr);
 #endif
 
   // Return a 512k stack size, (conservatively) assuming the following:
   //  - that size is much lower than the pthreads default (x86 pthreads has a 2M
   //    default.)
@@ skipping 42 matching lines @@
 #if OS(FREEBSD)
   pthread_attr_init(&attr);
   error = pthread_attr_get_np(pthread_self(), &attr);
 #else
   error = pthread_getattr_np(pthread_self(), &attr);
 #endif
   if (!error) {
     void* base;
     size_t size;
     error = pthread_attr_getstack(&attr, &base, &size);
-    RELEASE_ASSERT(!error);
+    CHECK(!error);
     pthread_attr_destroy(&attr);
     return reinterpret_cast<uint8_t*>(base) + size;
   }
 #if OS(FREEBSD)
   pthread_attr_destroy(&attr);
 #endif
 #if defined(__GLIBC__)
   // pthread_getattr_np can fail for the main thread. In this case
   // just like NaCl we rely on the __libc_stack_end to give us
   // the start of the stack.
@@ skipping 44 matching lines @@
   // tracks the end of the committed range. We're after the end of the reserved
   // stack area (most of which will be uncommitted, most times.)
   MEMORY_BASIC_INFORMATION stack_info;
   memset(&stack_info, 0, sizeof(MEMORY_BASIC_INFORMATION));
   size_t result_size =
       VirtualQuery(&stack_info, &stack_info, sizeof(MEMORY_BASIC_INFORMATION));
   DCHECK_GE(result_size, sizeof(MEMORY_BASIC_INFORMATION));
   uint8_t* stack_end = reinterpret_cast<uint8_t*>(stack_info.AllocationBase);
 
   uint8_t* stack_start = reinterpret_cast<uint8_t*>(WTF::GetStackStart());
-  RELEASE_ASSERT(stack_start && stack_start > stack_end);
+  CHECK(stack_start);
+  CHECK_GT(stack_start, stack_end);
   size_t thread_stack_size = static_cast<size_t>(stack_start - stack_end);
   // When the third last page of the reserved stack is accessed as a
   // guard page, the second last page will be committed (along with removing
   // the guard bit on the third last) _and_ a stack overflow exception
   // is raised.
   //
   // We have zero interest in running into stack overflow exceptions while
   // marking objects, so simply consider the last three pages + one above
   // as off-limits and adjust the reported stack size accordingly.
   //
   // http://blogs.msdn.com/b/satyem/archive/2012/08/13/thread-s-stack-memory-management.aspx
   // explains the details.
-  RELEASE_ASSERT(thread_stack_size > 4 * 0x1000);
+  CHECK_GT(thread_stack_size, 4u * 0x1000);
   thread_stack_size -= 4 * 0x1000;
   return thread_stack_size;
 }
 #endif
 
 }  // namespace internal
 
 }  // namespace WTF