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 *data_.string8_ptr; }
 
   UChar GetCurrentChar16() {
     return data_.string16_ptr ? *data_.string16_ptr : 0;
   }
 
   UChar IncrementAndGetCurrentChar8() {
-    ASSERT(data_.string8_ptr);
+    DCHECK(data_.string8_ptr);
     return *++data_.string8_ptr;
   }
 
   UChar IncrementAndGetCurrentChar16() {
-    ASSERT(data_.string16_ptr);
+    DCHECK(data_.string16_ptr);
     return *++data_.string16_ptr;
   }
 
   String CurrentSubString(unsigned length) {
     int offset = string_.length() - length_;
     return string_.Substring(offset, length);
   }
 
   ALWAYS_INLINE UChar GetCurrentChar() {
-    ASSERT(length_);
+    DCHECK(length_);
     if (Is8Bit())
       return GetCurrentChar8();
     return GetCurrentChar16();
   }
 
   ALWAYS_INLINE UChar IncrementAndGetCurrentChar() {
-    ASSERT(length_);
+    DCHECK(length_);
     if (Is8Bit())
       return IncrementAndGetCurrentChar8();
     return IncrementAndGetCurrentChar16();
   }
 
   ALWAYS_INLINE bool HaveOneCharacterLeft() const { return length_ == 1; }
 
   ALWAYS_INLINE void DecrementLength() { --length_; }
 
   ALWAYS_INLINE int length() const { return length_; }
@@ skipping 109 matching lines @@
     Advance();
   }
 
   void AdvanceAndASSERTIgnoringCase(UChar expected_character) {
     DCHECK_EQ(WTF::Unicode::FoldCase(CurrentChar()),
               WTF::Unicode::FoldCase(expected_character));
     Advance();
   }
 
   void AdvancePastNonNewline() {
-    ASSERT(CurrentChar() != '\n');
+    DCHECK_NE(CurrentChar(), '\n');
     Advance();
   }
 
   void AdvancePastNewlineAndUpdateLineNumber() {
-    ASSERT(CurrentChar() == '\n');
+    DCHECK_EQ(CurrentChar(), '\n');
     if (current_string_.length() > 1) {
       int new_line_flag = current_string_.DoNotExcludeLineNumbers();
       current_line_ += new_line_flag;
       if (new_line_flag)
         number_of_characters_consumed_prior_to_current_line_ =
             NumberOfCharactersConsumed() + 1;
       DecrementAndCheckLength();
       current_char_ = current_string_.IncrementAndGetCurrentChar();
       return;
     }
@@ skipping 40 matching lines @@
   void AdvanceAndUpdateLineNumber8();
   void AdvanceAndUpdateLineNumber16();
   void AdvanceSlowCase();
   void AdvanceAndUpdateLineNumberSlowCase();
   void AdvanceEmpty();
   void AdvanceSubstring();
 
   void UpdateSlowCaseFunctionPointers();
 
   void DecrementAndCheckLength() {
-    ASSERT(current_string_.length() > 1);
+    DCHECK_GT(current_string_.length(), 1);
     current_string_.DecrementLength();
     if (current_string_.HaveOneCharacterLeft())
       UpdateSlowCaseFunctionPointers();
   }
 
   void UpdateAdvanceFunctionPointers() {
     if (current_string_.length() > 1) {
       if (current_string_.Is8Bit()) {
         advance_func_ = &SegmentedString::Advance8;
         fast_path_flags_ = kUse8BitAdvance;
@@ skipping 65 matching lines @@
   bool closed_;
   bool empty_;
   unsigned char fast_path_flags_;
   void (SegmentedString::*advance_func_)();
   void (SegmentedString::*advance_and_update_line_number_func_)();
 };
 
 }  // namespace blink
 
 #endif