Replace all occurrences of RELEASE_ASSERT in wtf with CHECK.

third_party/WebKit/Source/wtf/allocator/PartitionAlloc.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 62 matching lines @@
     // TODO: we end up using a lot of system pages for very small sizes. For
     // example, we'll use 12 system pages for slot size 24. The slot size is
     // so small that the waste would be tiny with just 4, or 1, system pages.
     // Later, we can investigate whether there are anti-fragmentation benefits
     // to using fewer system pages.
     double bestWasteRatio = 1.0f;
     uint16_t bestPages = 0;
     if (size > kMaxSystemPagesPerSlotSpan * kSystemPageSize) {
         ASSERT(!(size % kSystemPageSize));
         bestPages = static_cast<uint16_t>(size / kSystemPageSize);
-        RELEASE_ASSERT(bestPages < (1 << 8));
+        CHECK_LT(bestPages, 1 << 8);
         return static_cast<uint8_t>(bestPages);
     }
     ASSERT(size <= kMaxSystemPagesPerSlotSpan * kSystemPageSize);
     for (uint16_t i = kNumSystemPagesPerPartitionPage - 1; i <= kMaxSystemPagesPerSlotSpan; ++i) {
         size_t pageSize = kSystemPageSize * i;
         size_t numSlots = pageSize / size;
         size_t waste = pageSize - (numSlots * size);
         // Leaving a page unfaulted is not free; the page will occupy an empty page table entry.
         // Make a simple attempt to account for that.
         size_t numRemainderPages = i & (kNumSystemPagesPerPartitionPage - 1);
         size_t numUnfaultedPages = numRemainderPages ? (kNumSystemPagesPerPartitionPage - numRemainderPages) : 0;
         waste += sizeof(void*) * numUnfaultedPages;
         double wasteRatio = (double) waste / (double) pageSize;
         if (wasteRatio < bestWasteRatio) {
             bestWasteRatio = wasteRatio;
             bestPages = i;
         }
     }
     ASSERT(bestPages > 0);
-    RELEASE_ASSERT(bestPages <= kMaxSystemPagesPerSlotSpan);
+    CHECK_LE(bestPages, kMaxSystemPagesPerSlotSpan);
     return static_cast<uint8_t>(bestPages);
 }
 
 static void partitionAllocBaseInit(PartitionRootBase* root)
 {
     ASSERT(!root->initialized);
     {
         SpinLock::Guard guard(PartitionRootBase::gInitializedLock);
         if (!PartitionRootBase::gInitialized) {
             PartitionRootBase::gInitialized = true;
@@ skipping 888 matching lines @@
 
         // Shrink by decommitting unneeded pages and making them inaccessible.
         size_t decommitSize = currentSize - newSize;
         partitionDecommitSystemPages(root, charPtr + newSize, decommitSize);
         setSystemPagesInaccessible(charPtr + newSize, decommitSize);
     } else if (newSize <= partitionPageToDirectMapExtent(page)->mapSize) {
         // Grow within the actually allocated memory. Just need to make the
         // pages accessible again.
         size_t recommitSize = newSize - currentSize;
         bool ret = setSystemPagesAccessible(charPtr + currentSize, recommitSize);
-        RELEASE_ASSERT(ret);
+        CHECK(ret);
         partitionRecommitSystemPages(root, charPtr + currentSize, recommitSize);
 
 #if ENABLE(ASSERT)
         memset(charPtr + currentSize, kUninitializedByte, recommitSize);
 #endif
     } else {
         // We can't perform the realloc in-place.
         // TODO: support this too when possible.
         return false;
     }
@@ skipping 379 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF