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 adjust_mid_cluster) const {
-  ASSERT(offset < num_characters_);
+  DCHECK_LT(offset, num_characters_);
   if (Rtl())
     offset = num_characters_ - offset - 1;
   return XPositionForOffset(offset, adjust_mid_cluster);
 }
 
 float ShapeResult::RunInfo::XPositionForOffset(
     unsigned offset,
     AdjustMidCluster adjust_mid_cluster) const {
-  ASSERT(offset <= num_characters_);
+  DCHECK_LE(offset, num_characters_);
   const unsigned num_glyphs = glyph_data_.size();
   unsigned glyph_index = 0;
   float position = 0;
   if (Rtl()) {
     while (glyph_index < num_glyphs &&
            glyph_data_[glyph_index].character_index > offset) {
       position += glyph_data_[glyph_index].advance;
       ++glyph_index;
     }
     // Adjust offset if it's not on the cluster boundary. In RTL, this means
@@ skipping 195 matching lines @@
 
   // The position in question might be just after the text.
   if (!offset_x && absolute_offset == NumCharacters())
     return Rtl() ? 0 : width_;
 
   return offset_x;
 }
 
 void ShapeResult::FallbackFonts(
     HashSet<const SimpleFontData*>* fallback) const {
-  ASSERT(fallback);
-  ASSERT(primary_font_);
+  DCHECK(fallback);
+  DCHECK(primary_font_);
   for (unsigned i = 0; i < runs_.size(); ++i) {
     if (runs_[i] && runs_[i]->font_data_ &&
         runs_[i]->font_data_ != primary_font_ &&
         !runs_[i]->font_data_->IsTextOrientationFallbackOf(
             primary_font_.Get())) {
       fallback->insert(runs_[i]->font_data_.Get());
     }
   }
 }
 
@@ skipping 52 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> run_to_insert,
                             unsigned start_glyph,
                             unsigned num_glyphs,
                             hb_buffer_t* harf_buzz_buffer) {
-  ASSERT(num_glyphs > 0);
+  DCHECK_GT(num_glyphs, 0u);
   std::unique_ptr<ShapeResult::RunInfo> run(std::move(run_to_insert));
-  ASSERT(num_glyphs == run->glyph_data_.size());
+  DCHECK_EQ(num_glyphs, run->glyph_data_.size());
 
   const SimpleFontData* current_font_data = run->font_data_.Get();
   const hb_glyph_info_t* glyph_infos =
       hb_buffer_get_glyph_infos(harf_buzz_buffer, 0);
   const hb_glyph_position_t* glyph_positions =
       hb_buffer_get_glyph_positions(harf_buzz_buffer, 0);
   const unsigned start_cluster =
       HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harf_buzz_buffer))
           ? glyph_infos[start_glyph].cluster
           : glyph_infos[start_glyph + num_glyphs - 1].cluster;
@@ skipping 28 matching lines @@
 
     FloatRect glyph_bounds = current_font_data->BoundsForGlyph(glyph);
     glyph_bounds.Move(glyph_origin.X(), glyph_origin.Y());
     glyph_bounding_box_.Unite(glyph_bounds);
     glyph_origin += FloatSize(advance + offset_x, offset_y);
   }
 
   run->width_ = std::max(0.0f, total_advance);
   width_ += run->width_;
   num_glyphs_ += num_glyphs;
-  ASSERT(num_glyphs_ >= num_glyphs);
+  DCHECK_GE(num_glyphs_, num_glyphs);
   has_vertical_offsets_ |= has_vertical_offsets;
 
   // 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->direction_)) {
     for (size_t pos = 0; pos < runs_.size(); ++pos) {
       if (runs_.at(pos)->start_index_ > run->start_index_) {
         runs_.insert(pos, std::move(run));
@@ skipping 64 matching lines @@
   result->width_ = run->width_;
   result->num_glyphs_ = count;
   DCHECK_EQ(result->num_glyphs_, count);  // no overflow
   result->has_vertical_offsets_ =
       font_data->PlatformData().IsVerticalAnyUpright();
   result->runs_.push_back(std::move(run));
   return result.Release();
 }
 
 }  // namespace blink