Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/fonts

third_party/WebKit/Source/platform/fonts/shaping/CachingWordShapeIterator.h

 /*
  * Copyright (C) 2015 Google 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 32 matching lines @@
  public:
   CachingWordShapeIterator(ShapeCache* cache,
                            const TextRun& run,
                            const Font* font)
       : shape_cache_(cache),
         text_run_(run),
         font_(font),
         spacing_(run, font->GetFontDescription()),
         width_so_far_(0),
         start_index_(0) {
-    ASSERT(font);
+    DCHECK(font);
 
     // Shaping word by word is faster as each word is cached. If we cannot
     // use the cache or if the font doesn't support word by word shaping
     // fall back on shaping the entire run.
     shape_by_word_ = font_->CanShapeWordByWord();
   }
 
   bool Next(RefPtr<const ShapeResult>* word_result) {
     if (UNLIKELY(text_run_.AllowTabs()))
       return NextForAllowTabs(word_result);
@@ skipping 84 matching lines @@
   }
 
   bool ShapeToEndIndex(RefPtr<const ShapeResult>* result, unsigned end_index) {
     if (!end_index || end_index <= start_index_)
       return false;
 
     const unsigned length = text_run_.length();
     if (!start_index_ && end_index == length) {
       *result = ShapeWord(text_run_, font_);
     } else {
-      ASSERT(end_index <= length);
+      DCHECK_LE(end_index, length);
       TextRun sub_run =
           text_run_.SubRun(start_index_, end_index - start_index_);
       *result = ShapeWord(sub_run, font_);
     }
     start_index_ = end_index;
     return result->Get();
   }
 
   unsigned EndIndexUntil(UChar ch) const {
     unsigned length = text_run_.length();
-    ASSERT(start_index_ < length);
+    DCHECK_LT(start_index_, length);
     for (unsigned i = start_index_ + 1;; i++) {
       if (i == length || text_run_[i] == ch)
         return i;
     }
   }
 
   bool NextForAllowTabs(RefPtr<const ShapeResult>* word_result) {
     unsigned length = text_run_.length();
     if (start_index_ >= length)
       return false;
 
     if (UNLIKELY(text_run_[start_index_] == kTabulationCharacter)) {
       for (unsigned i = start_index_ + 1;; i++) {
         if (i == length || text_run_[i] != kTabulationCharacter) {
           *word_result = ShapeResult::CreateForTabulationCharacters(
               font_, text_run_, width_so_far_, i - start_index_);
           start_index_ = i;
           break;
         }
       }
     } else if (!shape_by_word_) {
       if (!ShapeToEndIndex(word_result, EndIndexUntil(kTabulationCharacter)))
         return false;
     } else {
       if (!NextWord(word_result))
         return false;
     }
-    ASSERT(*word_result);
+    DCHECK(*word_result);
     width_so_far_ += (*word_result)->Width();
     return true;
   }
 
   ShapeCache* shape_cache_;
   const TextRun& text_run_;
   const Font* font_;
   ShapeResultSpacing spacing_;
   float width_so_far_;  // Used only when allowTabs()
   unsigned start_index_ : 31;
   unsigned shape_by_word_ : 1;
 };
 
 }  // namespace blink
 
 #endif  // CachingWordShapeIterator_h