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 @@
   current_line_ = 0;
   substrings_.Clear();
   closed_ = false;
   empty_ = true;
   fast_path_flags_ = kNoFastPath;
   advance_func_ = &SegmentedString::AdvanceEmpty;
   advance_and_update_line_number_func_ = &SegmentedString::AdvanceEmpty;
 }
 
 void SegmentedString::Append(const SegmentedSubstring& s) {
-  ASSERT(!closed_);
+  DCHECK(!closed_);
   if (!s.length())
     return;
 
   if (!current_string_.length()) {
     number_of_characters_consumed_prior_to_current_string_ +=
         current_string_.NumberOfCharactersConsumed();
     current_string_ = s;
     UpdateAdvanceFunctionPointers();
   } else {
     substrings_.push_back(s);
   }
   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 (current_string_.PushIfPossible(c)) {
     current_char_ = c;
     return;
   }
 
   Prepend(SegmentedString(String(&c, 1)), PrependType::kUnconsume);
 }
 
 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.
   number_of_characters_consumed_prior_to_current_string_ +=
       current_string_.NumberOfCharactersConsumed();
   if (type == PrependType::kUnconsume)
     number_of_characters_consumed_prior_to_current_string_ -= s.length();
   if (!current_string_.length()) {
     current_string_ = s;
     UpdateAdvanceFunctionPointers();
   } else {
     // Shift our m_currentString into our list.
     substrings_.push_front(current_string_);
     current_string_ = s;
     UpdateAdvanceFunctionPointers();
   }
   empty_ = false;
 }
 
 void SegmentedString::Close() {
   // Closing a stream twice is likely a coding mistake.
-  ASSERT(!closed_);
+  DCHECK(!closed_);
   closed_ = true;
 }
 
 void SegmentedString::Append(const SegmentedString& s) {
-  ASSERT(!closed_);
+  DCHECK(!closed_);
 
   Append(s.current_string_);
   if (s.IsComposite()) {
     Deque<SegmentedSubstring>::const_iterator it = s.substrings_.begin();
     Deque<SegmentedSubstring>::const_iterator e = s.substrings_.end();
     for (; it != e; ++it)
       Append(*it);
   }
   current_char_ =
       current_string_.length() ? current_string_.GetCurrentChar() : 0;
@@ skipping 56 matching lines @@
   DecrementAndCheckLength();
   current_char_ = current_string_.IncrementAndGetCurrentChar8();
 }
 
 void SegmentedString::Advance16() {
   DecrementAndCheckLength();
   current_char_ = current_string_.IncrementAndGetCurrentChar16();
 }
 
 void SegmentedString::AdvanceAndUpdateLineNumber8() {
-  ASSERT(current_string_.GetCurrentChar() == current_char_);
+  DCHECK_EQ(current_string_.GetCurrentChar(), current_char_);
   if (current_char_ == '\n') {
     ++current_line_;
     number_of_characters_consumed_prior_to_current_line_ =
         NumberOfCharactersConsumed() + 1;
   }
   DecrementAndCheckLength();
   current_char_ = current_string_.IncrementAndGetCurrentChar8();
 }
 
 void SegmentedString::AdvanceAndUpdateLineNumber16() {
-  ASSERT(current_string_.GetCurrentChar() == current_char_);
+  DCHECK_EQ(current_string_.GetCurrentChar(), current_char_);
   if (current_char_ == '\n') {
     ++current_line_;
     number_of_characters_consumed_prior_to_current_line_ =
         NumberOfCharactersConsumed() + 1;
   }
   DecrementAndCheckLength();
   current_char_ = current_string_.IncrementAndGetCurrentChar16();
 }
 
 void SegmentedString::AdvanceSlowCase() {
@@ skipping 33 matching lines @@
     fast_path_flags_ = kNoFastPath;
     advance_func_ = &SegmentedString::AdvanceEmpty;
     advance_and_update_line_number_func_ = &SegmentedString::AdvanceEmpty;
   }
 
   current_char_ =
       current_string_.length() ? current_string_.GetCurrentChar() : 0;
 }
 
 void SegmentedString::AdvanceEmpty() {
-  ASSERT(!current_string_.length() && !IsComposite());
+  DCHECK(!current_string_.length());
+  DCHECK(!IsComposite());
   current_char_ = 0;
 }
 
 void SegmentedString::UpdateSlowCaseFunctionPointers() {
   fast_path_flags_ = kNoFastPath;
   advance_func_ = &SegmentedString::AdvanceSlowCase;
   advance_and_update_line_number_func_ =
       &SegmentedString::AdvanceAndUpdateLineNumberSlowCase;
 }
 
@@ skipping 10 matching lines @@
 void SegmentedString::SetCurrentPosition(OrdinalNumber line,
                                          OrdinalNumber column_aftre_prolog,
                                          int prolog_length) {
   current_line_ = line.ZeroBasedInt();
   number_of_characters_consumed_prior_to_current_line_ =
       NumberOfCharactersConsumed() + prolog_length -
       column_aftre_prolog.ZeroBasedInt();
 }
 
 }  // namespace blink