Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/wtf

third_party/WebKit/Source/platform/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 85 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 (impl_->Is8Bit() && string.Is8Bit()) {
     LChar* data;
-    RELEASE_ASSERT(string.length() <=
-                   std::numeric_limits<unsigned>::max() - impl_->length());
+    CHECK_LE(string.length(),
+             std::numeric_limits<unsigned>::max() - impl_->length());
     RefPtr<StringImpl> new_impl = StringImpl::CreateUninitialized(
         impl_->length() + string.length(), data);
     memcpy(data, impl_->Characters8(), impl_->length() * sizeof(LChar));
     memcpy(data + impl_->length(), string.Characters8(),
            string.length() * sizeof(LChar));
     impl_ = new_impl.Release();
     return;
   }
 
   UChar* data;
-  RELEASE_ASSERT(string.length() <=
-                 std::numeric_limits<unsigned>::max() - impl_->length());
+  CHECK_LE(string.length(),
+           std::numeric_limits<unsigned>::max() - impl_->length());
   RefPtr<StringImpl> new_impl =
       StringImpl::CreateUninitialized(impl_->length() + string.length(), data);
 
   if (impl_->Is8Bit())
     StringImpl::CopyChars(data, impl_->Characters8(), impl_->length());
   else
     StringImpl::CopyChars(data, impl_->Characters16(), impl_->length());
 
   if (string.Is8Bit())
     StringImpl::CopyChars(data + impl_->length(), string.Characters8(),
@@ skipping 11 matching lines @@
   // 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 (!impl_) {
     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(impl_->length() < std::numeric_limits<unsigned>::max());
+  CHECK_LT(impl_->length(), std::numeric_limits<unsigned>::max());
   RefPtr<StringImpl> new_impl =
       StringImpl::CreateUninitialized(impl_->length() + 1, data);
   if (impl_->Is8Bit())
     StringImpl::CopyChars(data, impl_->Characters8(), impl_->length());
   else
     StringImpl::CopyChars(data, impl_->Characters16(), impl_->length());
   data[impl_->length()] = c;
   impl_ = new_impl.Release();
 }
 
@@ skipping 17 matching lines @@
 template <typename CharType>
 PassRefPtr<StringImpl> InsertInternal(PassRefPtr<StringImpl> impl,
                                       const CharType* characters_to_insert,
                                       unsigned length_to_insert,
                                       unsigned position) {
   if (!length_to_insert)
     return impl;
 
   DCHECK(characters_to_insert);
   UChar* data;  // FIXME: We should be able to create an 8 bit string here.
-  RELEASE_ASSERT(length_to_insert <=
-                 std::numeric_limits<unsigned>::max() - impl->length());
+  CHECK_LE(length_to_insert,
+           std::numeric_limits<unsigned>::max() - impl->length());
   RefPtr<StringImpl> new_impl =
       StringImpl::CreateUninitialized(impl->length() + length_to_insert, data);
 
   if (impl->Is8Bit())
     StringImpl::CopyChars(data, impl->Characters8(), position);
   else
     StringImpl::CopyChars(data, impl->Characters16(), position);
 
   StringImpl::CopyChars(data + position, characters_to_insert,
                         length_to_insert);
@@ skipping 531 matching lines @@
 
   UChar* destination;
   String result = String::CreateUninitialized(length, destination);
 
   StringImpl::CopyChars(destination, source, length);
 
   return result;
 }
 
 String String::FromUTF8(const LChar* string_start, size_t length) {
-  RELEASE_ASSERT(length <= std::numeric_limits<unsigned>::max());
+  CHECK_LE(length, std::numeric_limits<unsigned>::max());
 
   if (!string_start)
     return String();
 
   if (!length)
     return g_empty_string;
 
   if (CharactersAreAllASCII(string_start, length))
     return StringImpl::Create(string_start, length);
 
@@ skipping 71 matching lines @@
   return out << '"';
 }
 
 #ifndef NDEBUG
 void String::Show() const {
   DataLogF("%s\n", AsciiDebug(Impl()).data());
 }
 #endif
 
 }  // namespace WTF