Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

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

 /*
     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 39 matching lines @@
   m_currentLine = 0;
   m_substrings.clear();
   m_closed = false;
   m_empty = true;
   m_fastPathFlags = NoFastPath;
   m_advanceFunc = &SegmentedString::advanceEmpty;
   m_advanceAndUpdateLineNumberFunc = &SegmentedString::advanceEmpty;
 }
 
 void SegmentedString::append(const SegmentedSubstring& s) {
-  ASSERT(!m_closed);
+  DCHECK(!m_closed);
   if (!s.length())
     return;
 
   if (!m_currentString.length()) {
     m_numberOfCharactersConsumedPriorToCurrentString +=
         m_currentString.numberOfCharactersConsumed();
     m_currentString = s;
     updateAdvanceFunctionPointers();
   } else {
     m_substrings.push_back(s);
   }
   m_empty = false;
 }
 
 void SegmentedString::push(UChar c) {
-  ASSERT(c);
+  DCHECK(c);
 
   // pushIfPossible attempts to rewind the pointer in the SegmentedSubstring,
   // however it will fail if the SegmentedSubstring is empty, or
   // when we prepended some text while consuming a SegmentedSubstring by
   // document.write().
   if (m_currentString.pushIfPossible(c)) {
     m_currentChar = c;
     return;
   }
 
   prepend(SegmentedString(String(&c, 1)), PrependType::Unconsume);
 }
 
 void SegmentedString::prepend(const SegmentedSubstring& s, PrependType type) {
-  ASSERT(!s.numberOfCharactersConsumed());
+  DCHECK(!s.numberOfCharactersConsumed());
   if (!s.length())
     return;
 
   // FIXME: We're also ASSERTing that s is a fresh SegmentedSubstring.
   //        The assumption is sufficient for our current use, but we might
   //        need to handle the more elaborate cases in the future.
   m_numberOfCharactersConsumedPriorToCurrentString +=
       m_currentString.numberOfCharactersConsumed();
   if (type == PrependType::Unconsume)
     m_numberOfCharactersConsumedPriorToCurrentString -= s.length();
   if (!m_currentString.length()) {
     m_currentString = s;
     updateAdvanceFunctionPointers();
   } else {
     // Shift our m_currentString into our list.
     m_substrings.push_front(m_currentString);
     m_currentString = s;
     updateAdvanceFunctionPointers();
   }
   m_empty = false;
 }
 
 void SegmentedString::close() {
   // Closing a stream twice is likely a coding mistake.
-  ASSERT(!m_closed);
+  DCHECK(!m_closed);
   m_closed = true;
 }
 
 void SegmentedString::append(const SegmentedString& s) {
-  ASSERT(!m_closed);
+  DCHECK(!m_closed);
 
   append(s.m_currentString);
   if (s.isComposite()) {
     Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin();
     Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end();
     for (; it != e; ++it)
       append(*it);
   }
   m_currentChar =
       m_currentString.length() ? m_currentString.getCurrentChar() : 0;
@@ skipping 56 matching lines @@
   decrementAndCheckLength();
   m_currentChar = m_currentString.incrementAndGetCurrentChar8();
 }
 
 void SegmentedString::advance16() {
   decrementAndCheckLength();
   m_currentChar = m_currentString.incrementAndGetCurrentChar16();
 }
 
 void SegmentedString::advanceAndUpdateLineNumber8() {
-  ASSERT(m_currentString.getCurrentChar() == m_currentChar);
+  DCHECK_EQ(m_currentString.getCurrentChar(), m_currentChar);
   if (m_currentChar == '\n') {
     ++m_currentLine;
     m_numberOfCharactersConsumedPriorToCurrentLine =
         numberOfCharactersConsumed() + 1;
   }
   decrementAndCheckLength();
   m_currentChar = m_currentString.incrementAndGetCurrentChar8();
 }
 
 void SegmentedString::advanceAndUpdateLineNumber16() {
-  ASSERT(m_currentString.getCurrentChar() == m_currentChar);
+  DCHECK_EQ(m_currentString.getCurrentChar(), m_currentChar);
   if (m_currentChar == '\n') {
     ++m_currentLine;
     m_numberOfCharactersConsumedPriorToCurrentLine =
         numberOfCharactersConsumed() + 1;
   }
   decrementAndCheckLength();
   m_currentChar = m_currentString.incrementAndGetCurrentChar16();
 }
 
 void SegmentedString::advanceSlowCase() {
@@ skipping 33 matching lines @@
     m_fastPathFlags = NoFastPath;
     m_advanceFunc = &SegmentedString::advanceEmpty;
     m_advanceAndUpdateLineNumberFunc = &SegmentedString::advanceEmpty;
   }
 
   m_currentChar =
       m_currentString.length() ? m_currentString.getCurrentChar() : 0;
 }
 
 void SegmentedString::advanceEmpty() {
-  ASSERT(!m_currentString.length() && !isComposite());
+  DCHECK(!m_currentString.length() && !isComposite());

[tkent, 2017/04/09 23:07:01]

Split this into two DCHECKs

[Hwanseung Lee, 2017/04/11 03:29:38]

Done.

   m_currentChar = 0;
 }
 
 void SegmentedString::updateSlowCaseFunctionPointers() {
   m_fastPathFlags = NoFastPath;
   m_advanceFunc = &SegmentedString::advanceSlowCase;
   m_advanceAndUpdateLineNumberFunc =
       &SegmentedString::advanceAndUpdateLineNumberSlowCase;
 }
 
@@ skipping 10 matching lines @@
 void SegmentedString::setCurrentPosition(OrdinalNumber line,
                                          OrdinalNumber columnAftreProlog,
                                          int prologLength) {
   m_currentLine = line.zeroBasedInt();
   m_numberOfCharactersConsumedPriorToCurrentLine =
       numberOfCharactersConsumed() + prologLength -
       columnAftreProlog.zeroBasedInt();
 }
 
 }  // namespace blink