Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

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

 /*
  * Copyright (C) 2004, 2006, 2008, 2011 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 73 matching lines @@
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   return lengths[firstByte];
 }
 
 static inline int decodeNonASCIISequence(const uint8_t* sequence,
                                          unsigned length) {
-  ASSERT(!isASCII(sequence[0]));
+  DCHECK(!isASCII(sequence[0]));
   if (length == 2) {
-    ASSERT(sequence[0] <= 0xDF);
+    DCHECK_LE(sequence[0], 0xDF);
     if (sequence[0] < 0xC2)
       return nonCharacter1;
     if (sequence[1] < 0x80 || sequence[1] > 0xBF)
       return nonCharacter1;
     return ((sequence[0] << 6) + sequence[1]) - 0x00003080;
   }
   if (length == 3) {
-    ASSERT(sequence[0] >= 0xE0 && sequence[0] <= 0xEF);
+    DCHECK_GE(sequence[0], 0xE0);
+    DCHECK_LE(sequence[0], 0xEF);
     switch (sequence[0]) {
       case 0xE0:
         if (sequence[1] < 0xA0 || sequence[1] > 0xBF)
           return nonCharacter1;
         break;
       case 0xED:
         if (sequence[1] < 0x80 || sequence[1] > 0x9F)
           return nonCharacter1;
         break;
       default:
         if (sequence[1] < 0x80 || sequence[1] > 0xBF)
           return nonCharacter1;
     }
     if (sequence[2] < 0x80 || sequence[2] > 0xBF)
       return nonCharacter2;
     return ((sequence[0] << 12) + (sequence[1] << 6) + sequence[2]) -
            0x000E2080;
   }
-  ASSERT(length == 4);
-  ASSERT(sequence[0] >= 0xF0 && sequence[0] <= 0xF4);
+  DCHECK_EQ(length, 4u);
+  DCHECK_GE(sequence[0], 0xF0);
+  DCHECK_LE(sequence[0], 0xF4);
   switch (sequence[0]) {
     case 0xF0:
       if (sequence[1] < 0x90 || sequence[1] > 0xBF)
         return nonCharacter1;
       break;
     case 0xF4:
       if (sequence[1] < 0x80 || sequence[1] > 0x8F)
         return nonCharacter1;
       break;
     default:
@@ skipping 37 matching lines @@
   consumePartialSequenceByte();
 }
 
 template <>
 bool TextCodecUTF8::handlePartialSequence<LChar>(LChar*& destination,
                                                  const uint8_t*& source,
                                                  const uint8_t* end,
                                                  bool flush,
                                                  bool,
                                                  bool&) {
-  ASSERT(m_partialSequenceSize);
+  DCHECK(m_partialSequenceSize);
   do {
     if (isASCII(m_partialSequence[0])) {
       *destination++ = m_partialSequence[0];
       consumePartialSequenceByte();
       continue;
     }
     int count = nonASCIISequenceLength(m_partialSequence[0]);
     if (!count)
       return true;
 
@@ skipping 28 matching lines @@
   return false;
 }
 
 template <>
 bool TextCodecUTF8::handlePartialSequence<UChar>(UChar*& destination,
                                                  const uint8_t*& source,
                                                  const uint8_t* end,
                                                  bool flush,
                                                  bool stopOnError,
                                                  bool& sawError) {
-  ASSERT(m_partialSequenceSize);
+  DCHECK(m_partialSequenceSize);
   do {
     if (isASCII(m_partialSequence[0])) {
       *destination++ = m_partialSequence[0];
       consumePartialSequenceByte();
       continue;
     }
     int count = nonASCIISequenceLength(m_partialSequence[0]);
     if (!count) {
       handleError(destination, stopOnError, sawError);
       if (stopOnError)
@@ skipping 92 matching lines @@
         continue;
       }
       int count = nonASCIISequenceLength(*source);
       int character;
       if (count == 0) {
         character = nonCharacter1;
       } else {
         if (count > end - source) {
           SECURITY_DCHECK(end - source <
                           static_cast<ptrdiff_t>(sizeof(m_partialSequence)));
-          ASSERT(!m_partialSequenceSize);
+          DCHECK(!m_partialSequenceSize);
           m_partialSequenceSize = end - source;
           memcpy(m_partialSequence, source, m_partialSequenceSize);
           source = end;
           break;
         }
         character = decodeNonASCIISequence(source, count);
       }
       if (isNonCharacter(character)) {
         sawError = true;
         if (stopOnError)
@@ skipping 60 matching lines @@
         continue;
       }
       int count = nonASCIISequenceLength(*source);
       int character;
       if (count == 0) {
         character = nonCharacter1;
       } else {
         if (count > end - source) {
           SECURITY_DCHECK(end - source <
                           static_cast<ptrdiff_t>(sizeof(m_partialSequence)));
-          ASSERT(!m_partialSequenceSize);
+          DCHECK(!m_partialSequenceSize);
           m_partialSequenceSize = end - source;
           memcpy(m_partialSequence, source, m_partialSequenceSize);
           source = end;
           break;
         }
         character = decodeNonASCIISequence(source, count);
       }
       if (isNonCharacter(character)) {
         sawError = true;
         if (stopOnError)
@@ skipping 51 matching lines @@
   return encodeCommon(characters, length);
 }
 
 CString TextCodecUTF8::encode(const LChar* characters,
                               size_t length,
                               UnencodableHandling) {
   return encodeCommon(characters, length);
 }
 
 }  // namespace WTF