Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

third_party/WebKit/Source/platform/text/SegmentedString.h

 /*
     Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
 
     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.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 100 matching lines @@
     return true;
   }
 
   UChar getCurrentChar8() { return *m_data.string8Ptr; }
 
   UChar getCurrentChar16() {
     return m_data.string16Ptr ? *m_data.string16Ptr : 0;
   }
 
   UChar incrementAndGetCurrentChar8() {
-    ASSERT(m_data.string8Ptr);
+    DCHECK(m_data.string8Ptr);
     return *++m_data.string8Ptr;
   }
 
   UChar incrementAndGetCurrentChar16() {
-    ASSERT(m_data.string16Ptr);
+    DCHECK(m_data.string16Ptr);
     return *++m_data.string16Ptr;
   }
 
   String currentSubString(unsigned length) {
     int offset = m_string.length() - m_length;
     return m_string.substring(offset, length);
   }
 
   ALWAYS_INLINE UChar getCurrentChar() {
-    ASSERT(m_length);
+    DCHECK(m_length);
     if (is8Bit())
       return getCurrentChar8();
     return getCurrentChar16();
   }
 
   ALWAYS_INLINE UChar incrementAndGetCurrentChar() {
-    ASSERT(m_length);
+    DCHECK(m_length);
     if (is8Bit())
       return incrementAndGetCurrentChar8();
     return incrementAndGetCurrentChar16();
   }
 
   ALWAYS_INLINE bool haveOneCharacterLeft() const { return m_length == 1; }
 
   ALWAYS_INLINE void decrementLength() { --m_length; }
 
   ALWAYS_INLINE int length() const { return m_length; }
@@ skipping 109 matching lines @@
     advance();
   }
 
   void advanceAndASSERTIgnoringCase(UChar expectedCharacter) {
     DCHECK_EQ(WTF::Unicode::foldCase(currentChar()),
               WTF::Unicode::foldCase(expectedCharacter));
     advance();
   }
 
   void advancePastNonNewline() {
-    ASSERT(currentChar() != '\n');
+    DCHECK_NE(currentChar(), '\n');
     advance();
   }
 
   void advancePastNewlineAndUpdateLineNumber() {
-    ASSERT(currentChar() == '\n');
+    DCHECK_EQ(currentChar(), '\n');
     if (m_currentString.length() > 1) {
       int newLineFlag = m_currentString.doNotExcludeLineNumbers();
       m_currentLine += newLineFlag;
       if (newLineFlag)
         m_numberOfCharactersConsumedPriorToCurrentLine =
             numberOfCharactersConsumed() + 1;
       decrementAndCheckLength();
       m_currentChar = m_currentString.incrementAndGetCurrentChar();
       return;
     }
@@ skipping 40 matching lines @@
   void advanceAndUpdateLineNumber8();
   void advanceAndUpdateLineNumber16();
   void advanceSlowCase();
   void advanceAndUpdateLineNumberSlowCase();
   void advanceEmpty();
   void advanceSubstring();
 
   void updateSlowCaseFunctionPointers();
 
   void decrementAndCheckLength() {
-    ASSERT(m_currentString.length() > 1);
+    DCHECK_GT(m_currentString.length(), 1);
     m_currentString.decrementLength();
     if (m_currentString.haveOneCharacterLeft())
       updateSlowCaseFunctionPointers();
   }
 
   void updateAdvanceFunctionPointers() {
     if (m_currentString.length() > 1) {
       if (m_currentString.is8Bit()) {
         m_advanceFunc = &SegmentedString::advance8;
         m_fastPathFlags = Use8BitAdvance;
@@ skipping 65 matching lines @@
   bool m_closed;
   bool m_empty;
   unsigned char m_fastPathFlags;
   void (SegmentedString::*m_advanceFunc)();
   void (SegmentedString::*m_advanceAndUpdateLineNumberFunc)();
 };
 
 }  // namespace blink
 
 #endif