Replace all occurrences of RELEASE_ASSERT in wtf with CHECK.

third_party/WebKit/Source/wtf/allocator/PageAllocator.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 91 matching lines @@
     size_t postSlack = baseLen - preSlack - trimLen;
     ASSERT(baseLen >= trimLen || preSlack || postSlack);
     ASSERT(preSlack < baseLen);
     ASSERT(postSlack < baseLen);
     void* ret = base;
 
 #if OS(POSIX) // On POSIX we can resize the allocation run.
     (void) pageAccessibility;
     if (preSlack) {
         int res = munmap(base, preSlack);
-        RELEASE_ASSERT(!res);
+        CHECK(!res);
         ret = reinterpret_cast<char*>(base) + preSlack;
     }
     if (postSlack) {
         int res = munmap(reinterpret_cast<char*>(ret) + trimLen, postSlack);
-        RELEASE_ASSERT(!res);
+        CHECK(!res);
     }
 #else // On Windows we can't resize the allocation run.
     if (preSlack || postSlack) {
         ret = reinterpret_cast<char*>(base) + preSlack;
         freePages(base, baseLen);
         ret = systemAllocPages(ret, trimLen, pageAccessibility);
     }
 #endif
 
     return ret;
@@ skipping 37 matching lines @@
         }
 
 #if !CPU(32BIT) // Keep trying random addresses on systems that have a large address space.
         addr = getRandomPageBase();
         addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(addr) & alignBaseMask);
 #endif
     }
 
     // Map a larger allocation so we can force alignment, but continue randomizing only on 64-bit POSIX.
     size_t tryLen = len + (align - kPageAllocationGranularity);
-    RELEASE_ASSERT(tryLen >= len);
+    CHECK_GE(tryLen, len);
     void* ret;
 
     do {
         // Don't continue to burn cycles on mandatory hints (Windows).
         addr = kHintIsAdvisory ? getRandomPageBase() : nullptr;
         ret = systemAllocPages(addr, tryLen, pageAccessibility);
     // The retries are for Windows, where a race can steal our mapping on resize.
     } while (ret && !(ret = trimMapping(ret, tryLen, len, align, pageAccessibility)));
 
     return ret;
 }
 
 void freePages(void* addr, size_t len)
 {
     ASSERT(!(reinterpret_cast<uintptr_t>(addr) & kPageAllocationGranularityOffsetMask));
     ASSERT(!(len & kPageAllocationGranularityOffsetMask));
 #if OS(POSIX)
     int ret = munmap(addr, len);
-    RELEASE_ASSERT(!ret);
+    CHECK(!ret);
 #else
     BOOL ret = VirtualFree(addr, 0, MEM_RELEASE);
-    RELEASE_ASSERT(ret);
+    CHECK(ret);
 #endif
 }
 
 void setSystemPagesInaccessible(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     int ret = mprotect(addr, len, PROT_NONE);
-    RELEASE_ASSERT(!ret);
+    CHECK(!ret);
 #else
     BOOL ret = VirtualFree(addr, len, MEM_DECOMMIT);
-    RELEASE_ASSERT(ret);
+    CHECK(ret);
 #endif
 }
 
 bool setSystemPagesAccessible(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     return !mprotect(addr, len, PROT_READ | PROT_WRITE);
 #else
     return !!VirtualAlloc(addr, len, MEM_COMMIT, PAGE_READWRITE);
 #endif
 }
 
 void decommitSystemPages(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     int ret = madvise(addr, len, MADV_FREE);
-    RELEASE_ASSERT(!ret);
+    CHECK(!ret);
 #else
     setSystemPagesInaccessible(addr, len);
 #endif
 }
 
 void recommitSystemPages(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     (void) addr;
 #else
-    RELEASE_ASSERT(setSystemPagesAccessible(addr, len));
+    CHECK(setSystemPagesAccessible(addr, len));
 #endif
 }
 
 void discardSystemPages(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     // On POSIX, the implementation detail is that discard and decommit are the
     // same, and lead to pages that are returned to the system immediately and
     // get replaced with zeroed pages when touched. So we just call
     // decommitSystemPages() here to avoid code duplication.
     decommitSystemPages(addr, len);
 #else
     // On Windows discarded pages are not returned to the system immediately and
     // not guaranteed to be zeroed when returned to the application.
     using DiscardVirtualMemoryFunction = DWORD(WINAPI*)(PVOID virtualAddress, SIZE_T size);
     static DiscardVirtualMemoryFunction discardVirtualMemory = reinterpret_cast<DiscardVirtualMemoryFunction>(-1);
     if (discardVirtualMemory == reinterpret_cast<DiscardVirtualMemoryFunction>(-1))
         discardVirtualMemory = reinterpret_cast<DiscardVirtualMemoryFunction>(GetProcAddress(GetModuleHandle(L"Kernel32.dll"), "DiscardVirtualMemory"));
     // Use DiscardVirtualMemory when available because it releases faster than MEM_RESET.
     DWORD ret = 1;
     if (discardVirtualMemory)
         ret = discardVirtualMemory(addr, len);
     // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on failure.
     if (ret) {
         void* ret = VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
-        RELEASE_ASSERT(ret);
+        CHECK(ret);
     }
 #endif
 }
 
 uint32_t getAllocPageErrorCode()
 {
     return acquireLoad(&s_allocPageErrorCode);
 }
 
 } // namespace WTF