Revert of Replace all occurrences of RELEASE_ASSERT in wtf with CHECK.

third_party/WebKit/Source/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 339 matching lines @@
 
     StaticStringsTable::const_iterator it = staticStrings().find(hash);
     if (it != staticStrings().end()) {
         ASSERT(!memcmp(string, it->value + 1, length * sizeof(LChar)));
         return it->value;
     }
 
     // Allocate a single buffer large enough to contain the StringImpl
     // struct as well as the data which it contains. This removes one
     // heap allocation from this call.
-    CHECK_LE(length, (std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar));
+    RELEASE_ASSERT(length <= ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar)));
     size_t size = sizeof(StringImpl) + length * sizeof(LChar);
 
     WTF_INTERNAL_LEAK_SANITIZER_DISABLED_SCOPE;
     StringImpl* impl = static_cast<StringImpl*>(Partitions::bufferMalloc(size, "WTF::StringImpl"));
 
     LChar* data = reinterpret_cast<LChar*>(impl + 1);
     impl = new (impl) StringImpl(length, hash, StaticString);
     memcpy(data, string, length * sizeof(LChar));
 #if ENABLE(ASSERT)
     impl->assertHashIsCorrect();
@@ skipping 51 matching lines @@
     }
 
     return string.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::create(const LChar* string)
 {
     if (!string)
         return empty();
     size_t length = strlen(reinterpret_cast<const char*>(string));
-    CHECK_LE(length, numeric_limits<unsigned>::max());
+    RELEASE_ASSERT(length <= numeric_limits<unsigned>::max());
     return create(string, length);
 }
 
 bool StringImpl::containsOnlyWhitespace()
 {
     // FIXME: The definition of whitespace here includes a number of characters
     // that are not whitespace from the point of view of LayoutText; I wonder if
     // that's a problem in practice.
     if (is8Bit()) {
         for (unsigned i = 0; i < m_length; ++i) {
@@ skipping 75 matching lines @@
     const UChar* end = characters16() + m_length;
     for (const UChar* chp = characters16(); chp != end; ++chp) {
         if (isASCIIUpper(*chp))
             noUpper = false;
         ored |= *chp;
     }
     // Nothing to do if the string is all ASCII with no uppercase.
     if (noUpper && !(ored & ~0x7F))
         return this;
 
-    CHECK_LE(m_length, static_cast<unsigned>(numeric_limits<unsigned>::max()));
+    RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<unsigned>::max()));
     unsigned length = m_length;
 
     UChar* data16;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
     for (unsigned i = 0; i < length; ++i) {
         UChar c = characters16()[i];
         data16[i] = isASCIIUpper(c) ? toASCIILower(c) : c;
     }
     return newImpl.release();
@@ skipping 38 matching lines @@
     const UChar* end = characters16() + m_length;
     for (const UChar* chp = characters16(); chp != end; ++chp) {
         if (UNLIKELY(isASCIIUpper(*chp)))
             noUpper = false;
         ored |= *chp;
     }
     // Nothing to do if the string is all ASCII with no uppercase.
     if (noUpper && !(ored & ~0x7F))
         return this;
 
-    CHECK_LE(m_length, static_cast<unsigned>(numeric_limits<int32_t>::max()));
+    RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (!(ored & ~0x7F)) {
         UChar* data16;
         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
         for (int32_t i = 0; i < length; ++i) {
             UChar c = characters16()[i];
             data16[i] = toASCIILower(c);
         }
@@ skipping 15 matching lines @@
         return this;
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::upper()
 {
     // This function could be optimized for no-op cases the way lower() is,
     // but in empirical testing, few actual calls to upper() are no-ops, so
     // it wouldn't be worth the extra time for pre-scanning.
 
-    CHECK_LE(m_length, static_cast<unsigned>(numeric_limits<int32_t>::max()));
+    RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (is8Bit()) {
         LChar* data8;
         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data8);
 
         // Do a faster loop for the case where all the characters are ASCII.
         LChar ored = 0;
         for (int i = 0; i < length; ++i) {
             LChar c = characters8()[i];
@@ skipping 67 matching lines @@
     newImpl = createUninitialized(realLength, data16);
     Unicode::toUpper(data16, realLength, source16, m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
 static inline bool localeIdMatchesLang(const AtomicString& localeId, const char* lang)
 {
     size_t langLength = strlen(lang);
-    CHECK(langLength >= 2 && langLength <= 3);
+    RELEASE_ASSERT(langLength >= 2 && langLength <= 3);
     if (!localeId.impl() || !localeId.impl()->startsWithIgnoringCase(lang, langLength))
         return false;
     if (localeId.impl()->length() == langLength)
         return true;
     const UChar maybeDelimiter = (*localeId.impl())[langLength];
     return maybeDelimiter == '-' || maybeDelimiter == '_' || maybeDelimiter == '@';
 }
 
 typedef int32_t (*icuCaseConverter)(UChar*, int32_t, const UChar*, int32_t, const char*, UErrorCode*);
 
@@ skipping 93 matching lines @@
     }
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
     for (unsigned i = 0; i < m_length; ++i)
         data[i] = character;
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::foldCase()
 {
-    CHECK_LE(m_length, static_cast<unsigned>(numeric_limits<int32_t>::max()));
+    RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (is8Bit()) {
         // Do a faster loop for the case where all the characters are ASCII.
         LChar* data;
         RefPtr <StringImpl>newImpl = createUninitialized(m_length, data);
         LChar ored = 0;
 
         for (int32_t i = 0; i < length; ++i) {
             LChar c = characters8()[i];
@@ skipping 313 matching lines @@
         return WTF::find(characters8(), m_length, matchFunction, start);
     return WTF::find(characters16(), m_length, matchFunction, start);
 }
 
 size_t StringImpl::find(const LChar* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
         return kNotFound;
     size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
-    CHECK_LE(matchStringLength, numeric_limits<unsigned>::max());
+    RELEASE_ASSERT(matchStringLength <= numeric_limits<unsigned>::max());
     unsigned matchLength = matchStringLength;
     if (!matchLength)
         return min(index, length());
 
     // Optimization 1: fast case for strings of length 1.
     if (matchLength == 1)
         return WTF::find(characters16(), length(), *matchString, index);
 
     // Check index & matchLength are in range.
     if (index > length())
@@ skipping 41 matching lines @@
     }
     return index + i;
 }
 
 size_t StringImpl::findIgnoringCase(const LChar* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
         return kNotFound;
     size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
-    CHECK_LE(matchStringLength, numeric_limits<unsigned>::max());
+    RELEASE_ASSERT(matchStringLength <= numeric_limits<unsigned>::max());
     unsigned matchLength = matchStringLength;
     if (!matchLength)
         return min(index, length());
 
     // Check index & matchLength are in range.
     if (index > length())
         return kNotFound;
     unsigned searchLength = length() - index;
     if (matchLength > searchLength)
         return kNotFound;
@@ skipping 525 matching lines @@
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, StringImpl* str)
 {
     position = min(position, length());
     lengthToReplace = min(lengthToReplace, length() - position);
     unsigned lengthToInsert = str ? str->length() : 0;
     if (!lengthToReplace && !lengthToInsert)
         return this;
 
-    CHECK_LT(length() - lengthToReplace, numeric_limits<unsigned>::max() - lengthToInsert);
+    RELEASE_ASSERT((length() - lengthToReplace) < (numeric_limits<unsigned>::max() - lengthToInsert));
 
     if (is8Bit() && (!str || str->is8Bit())) {
         LChar* data;
         RefPtr<StringImpl> newImpl =
         createUninitialized(length() - lengthToReplace + lengthToInsert, data);
         memcpy(data, characters8(), position * sizeof(LChar));
         if (str)
             memcpy(data + position, str->characters8(), lengthToInsert * sizeof(LChar));
         memcpy(data + position + lengthToInsert, characters8() + position + lengthToReplace,
             (length() - position - lengthToReplace) * sizeof(LChar));
@@ skipping 45 matching lines @@
     // Count the matches.
     while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         ++srcSegmentStart;
     }
 
     // If we have 0 matches then we don't have to do any more work.
     if (!matchCount)
         return this;
 
-    CHECK(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
+    RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
     unsigned replaceSize = matchCount * repStrLength;
     unsigned newSize = m_length - matchCount;
-    CHECK_LT(newSize, numeric_limits<unsigned>::max() - replaceSize);
+    RELEASE_ASSERT(newSize < (numeric_limits<unsigned>::max() - replaceSize));
 
     newSize += replaceSize;
 
     // Construct the new data.
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
@@ skipping 50 matching lines @@
     // Count the matches.
     while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         ++srcSegmentStart;
     }
 
     // If we have 0 matches then we don't have to do any more work.
     if (!matchCount)
         return this;
 
-    CHECK(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
+    RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
     unsigned replaceSize = matchCount * repStrLength;
     unsigned newSize = m_length - matchCount;
-    CHECK_LT(newSize, numeric_limits<unsigned>::max() - replaceSize);
+    RELEASE_ASSERT(newSize < (numeric_limits<unsigned>::max() - replaceSize));
 
     newSize += replaceSize;
 
     // Construct the new data.
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
@@ skipping 60 matching lines @@
     while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         srcSegmentStart += patternLength;
     }
 
     // If we have 0 matches, we don't have to do any more work
     if (!matchCount)
         return this;
 
     unsigned newSize = m_length - matchCount * patternLength;
-    CHECK(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
+    RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
-    CHECK_LE(newSize, numeric_limits<unsigned>::max() - matchCount * repStrLength);
+    RELEASE_ASSERT(newSize <= (numeric_limits<unsigned>::max() - matchCount * repStrLength));
 
     newSize += matchCount * repStrLength;
 
 
     // Construct the new data
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
     bool srcIs8Bit = is8Bit();
@@ skipping 284 matching lines @@
     if (b->is8Bit())
         return equalIgnoringASCIICase(a->characters16(), b->characters8(), length);
     return equalIgnoringASCIICase(a->characters16(), b->characters16(), length);
 }
 
 bool equalIgnoringASCIICase(const StringImpl* a, const LChar* b)
 {
     if (!a || !b)
         return !a == !b;
     size_t length = strlen(reinterpret_cast<const char*>(b));
-    CHECK_LE(length, numeric_limits<unsigned>::max());
+    RELEASE_ASSERT(length <= numeric_limits<unsigned>::max());
     if (length != a->length())
         return false;
     return equalSubstringIgnoringASCIICase(a, 0, b, length);
 }
 
 size_t StringImpl::sizeInBytes() const
 {
     size_t size = length();
     if (!is8Bit())
         size *= 2;
@@ skipping 11 matching lines @@
         } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
             // TODO(rob.buis) implement upper-casing rules for lt
             // like in StringImpl::upper(locale).
         }
     }
 
     return toUpper(c);
 }
 
 } // namespace WTF