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)
       : m_shapeCache(cache),
         m_textRun(run),
         m_font(font),
         m_spacing(run, font->getFontDescription()),
         m_widthSoFar(0),
         m_startIndex(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.
     m_shapeByWord = m_font->canShapeWordByWord();
   }
 
   bool next(RefPtr<const ShapeResult>* wordResult) {
     if (UNLIKELY(m_textRun.allowTabs()))
       return nextForAllowTabs(wordResult);
@@ skipping 84 matching lines @@
   }
 
   bool shapeToEndIndex(RefPtr<const ShapeResult>* result, unsigned endIndex) {
     if (!endIndex || endIndex <= m_startIndex)
       return false;
 
     const unsigned length = m_textRun.length();
     if (!m_startIndex && endIndex == length) {
       *result = shapeWord(m_textRun, m_font);
     } else {
-      ASSERT(endIndex <= length);
+      DCHECK_LE(endIndex, length);
       TextRun subRun = m_textRun.subRun(m_startIndex, endIndex - m_startIndex);
       *result = shapeWord(subRun, m_font);
     }
     m_startIndex = endIndex;
     return result->get();
   }
 
   unsigned endIndexUntil(UChar ch) const {
     unsigned length = m_textRun.length();
-    ASSERT(m_startIndex < length);
+    DCHECK_LT(m_startIndex, length);
     for (unsigned i = m_startIndex + 1;; i++) {
       if (i == length || m_textRun[i] == ch)
         return i;
     }
   }
 
   bool nextForAllowTabs(RefPtr<const ShapeResult>* wordResult) {
     unsigned length = m_textRun.length();
     if (m_startIndex >= length)
       return false;
 
     if (UNLIKELY(m_textRun[m_startIndex] == tabulationCharacter)) {
       for (unsigned i = m_startIndex + 1;; i++) {
         if (i == length || m_textRun[i] != tabulationCharacter) {
           *wordResult = ShapeResult::createForTabulationCharacters(
               m_font, m_textRun, m_widthSoFar, i - m_startIndex);
           m_startIndex = i;
           break;
         }
       }
     } else if (!m_shapeByWord) {
       if (!shapeToEndIndex(wordResult, endIndexUntil(tabulationCharacter)))
         return false;
     } else {
       if (!nextWord(wordResult))
         return false;
     }
-    ASSERT(*wordResult);
+    DCHECK(*wordResult);
     m_widthSoFar += (*wordResult)->width();
     return true;
   }
 
   ShapeCache* m_shapeCache;
   const TextRun& m_textRun;
   const Font* m_font;
   ShapeResultSpacing m_spacing;
   float m_widthSoFar;  // Used only when allowTabs()
   unsigned m_startIndex : 31;
   unsigned m_shapeByWord : 1;
 };
 
 }  // namespace blink
 
 #endif  // CachingWordShapeIterator_h