Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/fonts

third_party/WebKit/Source/platform/fonts/shaping/ShapeResult.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 25 matching lines @@
 #include "platform/fonts/Font.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
 #include "platform/fonts/shaping/ShapeResultSpacing.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 float ShapeResult::RunInfo::xPositionForVisualOffset(
     unsigned offset,
     AdjustMidCluster adjustMidCluster) const {
-  ASSERT(offset < m_numCharacters);
+  DCHECK_LT(offset, m_numCharacters);
   if (rtl())
     offset = m_numCharacters - offset - 1;
   return xPositionForOffset(offset, adjustMidCluster);
 }
 
 float ShapeResult::RunInfo::xPositionForOffset(
     unsigned offset,
     AdjustMidCluster adjustMidCluster) const {
-  ASSERT(offset <= m_numCharacters);
+  DCHECK_LE(offset, m_numCharacters);
   const unsigned numGlyphs = m_glyphData.size();
   unsigned glyphIndex = 0;
   float position = 0;
   if (rtl()) {
     while (glyphIndex < numGlyphs &&
            m_glyphData[glyphIndex].characterIndex > offset) {
       position += m_glyphData[glyphIndex].advance;
       ++glyphIndex;
     }
     // Adjust offset if it's not on the cluster boundary. In RTL, this means
@@ skipping 193 matching lines @@
 
   // The position in question might be just after the text.
   if (!offsetX && absoluteOffset == numCharacters())
     return rtl() ? 0 : m_width;
 
   return offsetX;
 }
 
 void ShapeResult::fallbackFonts(
     HashSet<const SimpleFontData*>* fallback) const {
-  ASSERT(fallback);
-  ASSERT(m_primaryFont);
+  DCHECK(fallback);
+  DCHECK(m_primaryFont);
   for (unsigned i = 0; i < m_runs.size(); ++i) {
     if (m_runs[i] && m_runs[i]->m_fontData &&
         m_runs[i]->m_fontData != m_primaryFont &&
         !m_runs[i]->m_fontData->isTextOrientationFallbackOf(
             m_primaryFont.get())) {
       fallback->insert(m_runs[i]->m_fontData.get());
     }
   }
 }
 
@@ skipping 51 matching lines @@
 }
 
 static inline float harfBuzzPositionToFloat(hb_position_t value) {
   return static_cast<float>(value) / (1 << 16);
 }
 
 void ShapeResult::insertRun(std::unique_ptr<ShapeResult::RunInfo> runToInsert,
                             unsigned startGlyph,
                             unsigned numGlyphs,
                             hb_buffer_t* harfBuzzBuffer) {
-  ASSERT(numGlyphs > 0);
+  DCHECK_GT(numGlyphs, 0u);
   std::unique_ptr<ShapeResult::RunInfo> run(std::move(runToInsert));
-  ASSERT(numGlyphs == run->m_glyphData.size());
+  DCHECK_EQ(numGlyphs, run->m_glyphData.size());
 
   const SimpleFontData* currentFontData = run->m_fontData.get();
   const hb_glyph_info_t* glyphInfos =
       hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
   const hb_glyph_position_t* glyphPositions =
       hb_buffer_get_glyph_positions(harfBuzzBuffer, 0);
   const unsigned startCluster =
       HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harfBuzzBuffer))
           ? glyphInfos[startGlyph].cluster
           : glyphInfos[startGlyph + numGlyphs - 1].cluster;
@@ skipping 28 matching lines @@
 
     FloatRect glyphBounds = currentFontData->boundsForGlyph(glyph);
     glyphBounds.move(glyphOrigin.x(), glyphOrigin.y());
     m_glyphBoundingBox.unite(glyphBounds);
     glyphOrigin += FloatSize(advance + offsetX, offsetY);
   }
 
   run->m_width = std::max(0.0f, totalAdvance);
   m_width += run->m_width;
   m_numGlyphs += numGlyphs;
-  ASSERT(m_numGlyphs >= numGlyphs);
+  DCHECK_GE(m_numGlyphs, numGlyphs);
   m_hasVerticalOffsets |= hasVerticalOffsets;
 
   // The runs are stored in result->m_runs in visual order. For LTR, we place
   // the run to be inserted before the next run with a bigger character
   // start index. For RTL, we place the run before the next run with a lower
   // character index. Otherwise, for both directions, at the end.
   if (HB_DIRECTION_IS_FORWARD(run->m_direction)) {
     for (size_t pos = 0; pos < m_runs.size(); ++pos) {
       if (m_runs.at(pos)->m_startIndex > run->m_startIndex) {
         m_runs.insert(pos, std::move(run));
@@ skipping 64 matching lines @@
   result->m_width = run->m_width;
   result->m_numGlyphs = count;
   DCHECK_EQ(result->m_numGlyphs, count);  // no overflow
   result->m_hasVerticalOffsets =
       fontData->platformData().isVerticalAnyUpright();
   result->m_runs.push_back(std::move(run));
   return result.release();
 }
 
 }  // namespace blink