Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/wtf

third_party/WebKit/Source/platform/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
@@ skipping 415 matching lines @@
 
   StaticStringsTable::const_iterator it = StaticStrings().Find(hash);
   if (it != StaticStrings().end()) {
     DCHECK(!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.
-  RELEASE_ASSERT(length <=
-                 ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) /
-                  sizeof(LChar)));
+  CHECK_LE(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, kStaticString);
   memcpy(data, string, length * sizeof(LChar));
 #if DCHECK_IS_ON()
@@ skipping 54 matching lines @@
     data[i] = static_cast<LChar>(characters[i]);
   }
 
   return string.Release();
 }
 
 PassRefPtr<StringImpl> StringImpl::Create(const LChar* string) {
   if (!string)
     return empty_;
   size_t length = strlen(reinterpret_cast<const char*>(string));
-  RELEASE_ASSERT(length <= numeric_limits<unsigned>::max());
+  CHECK_LE(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 < length_; ++i) {
       UChar c = Characters8()[i];
@@ skipping 88 matching lines @@
   const UChar* end = Characters16() + length_;
   for (const UChar* chp = Characters16(); chp != end; ++chp) {
     if (IsASCIIUpper(*chp))
       no_upper = false;
     ored |= *chp;
   }
   // Nothing to do if the string is all ASCII with no uppercase.
   if (no_upper && !(ored & ~0x7F))
     return this;
 
-  RELEASE_ASSERT(length_ <=
-                 static_cast<unsigned>(numeric_limits<unsigned>::max()));
+  CHECK_LE(length_, static_cast<unsigned>(numeric_limits<unsigned>::max()));
   unsigned length = length_;
 
   UChar* data16;
   RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data16);
 
   for (unsigned i = 0; i < length; ++i) {
     UChar c = Characters16()[i];
     data16[i] = IsASCIIUpper(c) ? ToASCIILower(c) : c;
   }
   return new_impl.Release();
@@ skipping 37 matching lines @@
   const UChar* end = Characters16() + length_;
   for (const UChar* chp = Characters16(); chp != end; ++chp) {
     if (UNLIKELY(IsASCIIUpper(*chp)))
       no_upper = false;
     ored |= *chp;
   }
   // Nothing to do if the string is all ASCII with no uppercase.
   if (no_upper && !(ored & ~0x7F))
     return this;
 
-  RELEASE_ASSERT(length_ <=
-                 static_cast<unsigned>(numeric_limits<int32_t>::max()));
+  CHECK_LE(length_, static_cast<unsigned>(numeric_limits<int32_t>::max()));
   int32_t length = length_;
 
   if (!(ored & ~0x7F)) {
     UChar* data16;
     RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data16);
 
     for (int32_t i = 0; i < length; ++i) {
       UChar c = Characters16()[i];
       data16[i] = ToASCIILower(c);
     }
@@ skipping 15 matching lines @@
   if (error)
     return this;
   return new_impl.Release();
 }
 
 PassRefPtr<StringImpl> StringImpl::UpperUnicode() {
   // This function could be optimized for no-op cases the way LowerUnicode() is,
   // but in empirical testing, few actual calls to UpperUnicode() are no-ops, so
   // it wouldn't be worth the extra time for pre-scanning.
 
-  RELEASE_ASSERT(length_ <=
-                 static_cast<unsigned>(numeric_limits<int32_t>::max()));
+  CHECK_LE(length_, static_cast<unsigned>(numeric_limits<int32_t>::max()));
   int32_t length = length_;
 
   if (Is8Bit()) {
     LChar* data8;
     RefPtr<StringImpl> new_impl = CreateUninitialized(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 93 matching lines @@
 
   for (unsigned i = 0; i < length_; ++i) {
     UChar c = Characters16()[i];
     data16[i] = IsASCIILower(c) ? ToASCIIUpper(c) : c;
   }
   return new_impl.Release();
 }
 
 static inline bool LocaleIdMatchesLang(const AtomicString& locale_id,
                                        const StringView& lang) {
-  RELEASE_ASSERT(lang.length() >= 2 && lang.length() <= 3);
+  CHECK_GE(lang.length(), 2u);
+  CHECK_LE(lang.length(), 3u);
   if (!locale_id.Impl() || !locale_id.Impl()->StartsWithIgnoringCase(lang))
     return false;
   if (locale_id.Impl()->length() == lang.length())
     return true;
   const UChar maybe_delimiter = (*locale_id.Impl())[lang.length()];
   return maybe_delimiter == '-' || maybe_delimiter == '_' ||
          maybe_delimiter == '@';
 }
 
 typedef int32_t (*icuCaseConverter)(UChar*,
@@ skipping 90 matching lines @@
     return new_impl.Release();
   }
   UChar* data;
   RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data);
   for (unsigned i = 0; i < length_; ++i)
     data[i] = character;
   return new_impl.Release();
 }
 
 PassRefPtr<StringImpl> StringImpl::FoldCase() {
-  RELEASE_ASSERT(length_ <=
-                 static_cast<unsigned>(numeric_limits<int32_t>::max()));
+  CHECK_LE(length_, static_cast<unsigned>(numeric_limits<int32_t>::max()));
   int32_t length = length_;
 
   if (Is8Bit()) {
     // Do a faster loop for the case where all the characters are ASCII.
     LChar* data;
     RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data);
     LChar ored = 0;
 
     for (int32_t i = 0; i < length; ++i) {
       LChar c = Characters8()[i];
@@ skipping 798 matching lines @@
 // behavior.
 PassRefPtr<StringImpl> StringImpl::Replace(unsigned position,
                                            unsigned length_to_replace,
                                            const StringView& string) {
   position = min(position, length());
   length_to_replace = min(length_to_replace, length() - position);
   unsigned length_to_insert = string.length();
   if (!length_to_replace && !length_to_insert)
     return this;
 
-  RELEASE_ASSERT((length() - length_to_replace) <
-                 (numeric_limits<unsigned>::max() - length_to_insert));
+  CHECK_LT((length() - length_to_replace),
+           (numeric_limits<unsigned>::max() - length_to_insert));
 
   if (Is8Bit() && (string.IsNull() || string.Is8Bit())) {
     LChar* data;
     RefPtr<StringImpl> new_impl = CreateUninitialized(
         length() - length_to_replace + length_to_insert, data);
     memcpy(data, Characters8(), position * sizeof(LChar));
     if (!string.IsNull())
       memcpy(data + position, string.Characters8(),
              length_to_insert * sizeof(LChar));
     memcpy(data + position + length_to_insert,
@@ skipping 49 matching lines @@
   // Count the matches.
   while ((src_segment_start = Find(pattern, src_segment_start)) != kNotFound) {
     ++match_count;
     ++src_segment_start;
   }
 
   // If we have 0 matches then we don't have to do any more work.
   if (!match_count)
     return this;
 
-  RELEASE_ASSERT(!rep_str_length ||
-                 match_count <=
-                     numeric_limits<unsigned>::max() / rep_str_length);
+  CHECK(!rep_str_length ||
+        match_count <= numeric_limits<unsigned>::max() / rep_str_length);
 
   unsigned replace_size = match_count * rep_str_length;
   unsigned new_size = length_ - match_count;
-  RELEASE_ASSERT(new_size < (numeric_limits<unsigned>::max() - replace_size));
+  CHECK_LT(new_size, (numeric_limits<unsigned>::max() - replace_size));
 
   new_size += replace_size;
 
   // Construct the new data.
   size_t src_segment_end;
   unsigned src_segment_length;
   src_segment_start = 0;
   unsigned dst_offset = 0;
 
   if (Is8Bit()) {
@@ skipping 55 matching lines @@
   // Count the matches.
   while ((src_segment_start = Find(pattern, src_segment_start)) != kNotFound) {
     ++match_count;
     ++src_segment_start;
   }
 
   // If we have 0 matches then we don't have to do any more work.
   if (!match_count)
     return this;
 
-  RELEASE_ASSERT(!rep_str_length ||
-                 match_count <=
-                     numeric_limits<unsigned>::max() / rep_str_length);
+  CHECK(!rep_str_length ||
+        match_count <= numeric_limits<unsigned>::max() / rep_str_length);
 
   unsigned replace_size = match_count * rep_str_length;
   unsigned new_size = length_ - match_count;
-  RELEASE_ASSERT(new_size < (numeric_limits<unsigned>::max() - replace_size));
+  CHECK_LT(new_size, (numeric_limits<unsigned>::max() - replace_size));
 
   new_size += replace_size;
 
   // Construct the new data.
   size_t src_segment_end;
   unsigned src_segment_length;
   src_segment_start = 0;
   unsigned dst_offset = 0;
 
   if (Is8Bit()) {
@@ skipping 62 matching lines @@
   while ((src_segment_start = Find(pattern, src_segment_start)) != kNotFound) {
     ++match_count;
     src_segment_start += pattern_length;
   }
 
   // If we have 0 matches, we don't have to do any more work
   if (!match_count)
     return this;
 
   unsigned new_size = length_ - match_count * pattern_length;
-  RELEASE_ASSERT(!rep_str_length ||
-                 match_count <=
-                     numeric_limits<unsigned>::max() / rep_str_length);
+  CHECK(!rep_str_length ||
+        match_count <= numeric_limits<unsigned>::max() / rep_str_length);
 
-  RELEASE_ASSERT(new_size <= (numeric_limits<unsigned>::max() -
-                              match_count * rep_str_length));
+  CHECK_LE(new_size,
+           (numeric_limits<unsigned>::max() - match_count * rep_str_length));
 
   new_size += match_count * rep_str_length;
 
   // Construct the new data
   size_t src_segment_end;
   unsigned src_segment_length;
   src_segment_start = 0;
   unsigned dst_offset = 0;
   bool src_is8_bit = Is8Bit();
   bool replacement_is8_bit = replacement.Is8Bit();
@@ skipping 234 matching lines @@
     } else if (LocaleIdMatchesLang(locale_identifier, "lt")) {
       // TODO(rob.buis) implement upper-casing rules for lt
       // like in StringImpl::upper(locale).
     }
   }
 
   return ToUpper(c);
 }
 
 }  // namespace WTF