Replace all occurrences of RELEASE_ASSERT in wtf with CHECK.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 74 matching lines @@
         return;
     }
 
     // FIXME: This is extremely inefficient. So much so that we might want to
     // take this out of String's API. We can make it better by optimizing the
     // case where exactly one String is pointing at this StringImpl, but even
     // then it's going to require a call into the allocator every single time.
 
     if (m_impl->is8Bit() && string.m_impl->is8Bit()) {
         LChar* data;
-        RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
+        CHECK_LE(string.length(), std::numeric_limits<unsigned>::max() - m_impl->length());
         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
         memcpy(data, m_impl->characters8(), m_impl->length() * sizeof(LChar));
         memcpy(data + m_impl->length(), string.characters8(), string.length() * sizeof(LChar));
         m_impl = newImpl.release();
         return;
     }
 
     UChar* data;
-    RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
+    CHECK_LE(string.length(), std::numeric_limits<unsigned>::max() - m_impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
 
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, m_impl->characters8(), m_impl->length());
     else
         StringImpl::copyChars(data, m_impl->characters16(), m_impl->length());
 
     if (string.impl()->is8Bit())
         StringImpl::copyChars(data + m_impl->length(), string.impl()->characters8(), string.impl()->length());
     else
         StringImpl::copyChars(data + m_impl->length(), string.impl()->characters16(), string.impl()->length());
 
     m_impl = newImpl.release();
 }
 
 template <typename CharacterType>
 inline void String::appendInternal(CharacterType c)
 {
     // FIXME: This is extremely inefficient. So much so that we might want to
     // take this out of String's API. We can make it better by optimizing the
     // case where exactly one String is pointing at this StringImpl, but even
     // then it's going to require a call into the allocator every single time.
     if (!m_impl) {
         m_impl = StringImpl::create(&c, 1);
         return;
     }
 
     // FIXME: We should be able to create an 8 bit string via this code path.
     UChar* data;
-    RELEASE_ASSERT(m_impl->length() < std::numeric_limits<unsigned>::max());
+    CHECK_LT(m_impl->length(), std::numeric_limits<unsigned>::max());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data);
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, m_impl->characters8(), m_impl->length());
     else
         StringImpl::copyChars(data, m_impl->characters16(), m_impl->length());
     data[m_impl->length()] = c;
     m_impl = newImpl.release();
 }
 
 void String::append(LChar c)
@@ skipping 37 matching lines @@
     }
 
     if (!lengthToAppend)
         return;
 
     ASSERT(charactersToAppend);
 
     unsigned strLength = m_impl->length();
 
     if (m_impl->is8Bit()) {
-        RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
+        CHECK_LE(lengthToAppend, std::numeric_limits<unsigned>::max() - strLength);
         LChar* data;
         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
         StringImpl::copyChars(data, m_impl->characters8(), strLength);
         StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
         m_impl = newImpl.release();
         return;
     }
 
-    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
+    CHECK_LE(lengthToAppend, std::numeric_limits<unsigned>::max() - strLength);
     UChar* data;
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data);
     StringImpl::copyChars(data, m_impl->characters16(), strLength);
     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
     m_impl = newImpl.release();
 }
 
 void String::append(const UChar* charactersToAppend, unsigned lengthToAppend)
 {
     if (!m_impl) {
         if (!charactersToAppend)
             return;
         m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
         return;
     }
 
     if (!lengthToAppend)
         return;
 
     unsigned strLength = m_impl->length();
 
     ASSERT(charactersToAppend);
-    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
+    CHECK_LE(lengthToAppend, std::numeric_limits<unsigned>::max() - strLength);
     UChar* data;
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, characters8(), strLength);
     else
         StringImpl::copyChars(data, characters16(), strLength);
     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
     m_impl = newImpl.release();
 }
 
 template<typename CharType>
 PassRefPtr<StringImpl> insertInternal(PassRefPtr<StringImpl> impl, const CharType* charactersToInsert, unsigned lengthToInsert, unsigned position)
 {
     if (!lengthToInsert)
         return impl;
 
     ASSERT(charactersToInsert);
     UChar* data; // FIXME: We should be able to create an 8 bit string here.
-    RELEASE_ASSERT(lengthToInsert <= std::numeric_limits<unsigned>::max() - impl->length());
+    CHECK_LE(lengthToInsert, std::numeric_limits<unsigned>::max() - impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(impl->length() + lengthToInsert, data);
 
     if (impl->is8Bit())
         StringImpl::copyChars(data, impl->characters8(), position);
     else
         StringImpl::copyChars(data, impl->characters16(), position);
 
     StringImpl::copyChars(data + position, charactersToInsert, lengthToInsert);
 
     if (impl->is8Bit())
@@ skipping 171 matching lines @@
     Vector<UChar> result;
     result.reserveInitialCapacity(length() + 1);
     appendTo(result);
     result.append('\0');
     return result;
 }
 
 unsigned String::copyTo(UChar* buffer, unsigned pos, unsigned maxLength) const
 {
     unsigned length = this->length();
-    RELEASE_ASSERT(pos <= length);
+    CHECK_LE(pos, length);
     unsigned numCharacters = std::min(length - pos, maxLength);
     if (!numCharacters)
         return 0;
     if (is8Bit())
         StringImpl::copyChars(buffer, characters8() + pos, numCharacters);
     else
         StringImpl::copyChars(buffer, characters16() + pos, numCharacters);
     return numCharacters;
 }
 
@@ skipping 418 matching lines @@
     UChar* destination;
     String result = String::createUninitialized(length, destination);
 
     StringImpl::copyChars(destination, source, length);
 
     return result;
 }
 
 String String::fromUTF8(const LChar* stringStart, size_t length)
 {
-    RELEASE_ASSERT(length <= std::numeric_limits<unsigned>::max());
+    CHECK_LE(length, std::numeric_limits<unsigned>::max());
 
     if (!stringStart)
         return String();
 
     if (!length)
         return emptyString();
 
     if (charactersAreAllASCII(stringStart, length))
         return StringImpl::create(stringStart, length);
 
@@ skipping 396 matching lines @@
     buffer.append('\0');
     return buffer;
 }
 
 Vector<char> asciiDebug(String& string)
 {
     return asciiDebug(string.impl());
 }
 
 #endif