Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/html/parser/

third_party/WebKit/Source/core/html/parser/HTMLParserIdioms.cpp

 /*
  * Copyright (C) 2010 Apple 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 41 matching lines @@
   }
 
   if (numLeadingSpaces == length)
     return string.isNull() ? string : emptyAtom.getString();
 
   for (; numTrailingSpaces < length; ++numTrailingSpaces) {
     if (isNotHTMLSpace<CharType>(characters[length - numTrailingSpaces - 1]))
       break;
   }
 
-  ASSERT(numLeadingSpaces + numTrailingSpaces < length);
+  DCHECK_LT(numLeadingSpaces + numTrailingSpaces, length);
 
   if (!(numLeadingSpaces | numTrailingSpaces))
     return string;
 
   return string.substring(numLeadingSpaces,
                           length - (numLeadingSpaces + numTrailingSpaces));
 }
 
 String stripLeadingAndTrailingHTMLSpaces(const String& string) {
   unsigned length = string.length();
@@ skipping 93 matching lines @@
   // Step 4
   while (position < end) {
     if (!isHTMLSpace<CharacterType>(*position))
       break;
     ++position;
   }
 
   // Step 5
   if (position == end)
     return false;
-  ASSERT(position < end);
+  DCHECK_LT(position, end);
 
   // Step 6
   if (*position == '-') {
     isNegative = true;
     ++position;
   } else if (*position == '+')
     ++position;
   if (position == end)
     return false;
-  ASSERT(position < end);
+  DCHECK_LT(position, end);
 
   // Step 7
   if (!isASCIIDigit(*position))
     return false;
 
   // Step 8
   static const int intMax = std::numeric_limits<int>::max();
   const int base = 10;
   const int maxMultiplier = intMax / base;
 
@@ skipping 43 matching lines @@
   // Step 4: Skip whitespace.
   while (position < end) {
     if (!isHTMLSpace<CharacterType>(*position))
       break;
     ++position;
   }
 
   // Step 5: If position is past the end of input, return an error.
   if (position == end)
     return false;
-  ASSERT(position < end);
+  DCHECK_LT(position, end);
 
   // Step 6: If the character indicated by position (the first character) is a
   // U+002D HYPHEN-MINUS character (-), ...
   if (*position == '-') {
     sign = -1;
     ++position;
   } else if (*position == '+') {
     ++position;
   }
 
   if (position == end)
     return false;
-  ASSERT(position < end);
+  DCHECK_LT(position, end);
 
   // Step 7: If the character indicated by position is not an ASCII digit,
   // then return an error.
   if (!isASCIIDigit(*position))
     return false;
 
   // Step 8: Collect a sequence of characters ...
   StringBuilder digits;
   while (position < end) {
     if (!isASCIIDigit(*position))
@@ skipping 95 matching lines @@
       continue;
 
     ++pos;
 
     while (pos < length && value[pos] <= ' ')
       ++pos;
 
     char quoteMark = 0;
     if (pos < length && (value[pos] == '"' || value[pos] == '\'')) {
       quoteMark = static_cast<char>(value[pos++]);
-      ASSERT(!(quoteMark & 0x80));
+      DCHECK(!(quoteMark & 0x80));
     }
 
     if (pos == length)
       break;
 
     unsigned end = pos;
     while (end < length &&
            ((quoteMark && value[end] != quoteMark) ||
             (!quoteMark && value[end] > ' ' && value[end] != '"' &&
              value[end] != '\'' && value[end] != ';')))
@@ skipping 64 matching lines @@
 
 template <typename CharType>
 inline StringImpl* findStringIfStatic(const CharType* characters,
                                       unsigned length) {
   // We don't need to try hashing if we know the string is too long.
   if (length > StringImpl::highestStaticStringLength())
     return nullptr;
   // computeHashAndMaskTop8Bits is the function StringImpl::hash() uses.
   unsigned hash = StringHasher::computeHashAndMaskTop8Bits(characters, length);
   const WTF::StaticStringsTable& table = StringImpl::allStaticStrings();
-  ASSERT(!table.isEmpty());
+  DCHECK(!table.isEmpty());
 
   WTF::StaticStringsTable::const_iterator it = table.find(hash);
   if (it == table.end())
     return nullptr;
   // It's possible to have hash collisions between arbitrary strings and known
   // identifiers (e.g. "bvvfg" collides with "script"). However ASSERTs in
   // StringImpl::createStatic guard against there ever being collisions between
   // static strings.
   if (!equal(it->value, characters, length))
     return nullptr;
@@ skipping 17 matching lines @@
     string = StringImpl::create8BitIfPossible(characters, size);
   else if (width == Force8Bit)
     string = String::make8BitFrom16BitSource(characters, size);
   else
     string = String(characters, size);
 
   return string;
 }
 
 }  // namespace blink