Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/fonts

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

 /*
  * Copyright (c) 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 96 matching lines @@
 // Though we have FontCache class, which provides the cache mechanism for
 // WebKit's font objects, we also need additional caching layer for HarfBuzz to
 // reduce the number of hb_font_t objects created. Without it, we would create
 // an hb_font_t object for every FontPlatformData object. But insted, we only
 // need one for each unique SkTypeface.
 // FIXME, crbug.com/609099: We should fix the FontCache to only keep one
 // FontPlatformData object independent of size, then consider using this here.
 class HbFontCacheEntry : public RefCounted<HbFontCacheEntry> {
  public:
   static PassRefPtr<HbFontCacheEntry> Create(hb_font_t* hb_font) {
-    ASSERT(hb_font);
+    DCHECK(hb_font);
     return AdoptRef(new HbFontCacheEntry(hb_font));
   }
 
   hb_font_t* HbFont() { return hb_font_.get(); }
   HarfBuzzFontData* HbFontData() { return hb_font_data_.get(); }
 
  private:
   explicit HbFontCacheEntry(hb_font_t* font)
       : hb_font_(HbFontUniquePtr(font)),
         hb_font_data_(WTF::MakeUnique<HarfBuzzFontData>()){};
@@ skipping 24 matching lines @@
     result.stored_value->value = CreateHbFontCacheEntry(face.get());
   }
   result.stored_value->value->Ref();
   unscaled_font_ = result.stored_value->value->HbFont();
   harf_buzz_font_data_ = result.stored_value->value->HbFontData();
 }
 
 HarfBuzzFace::~HarfBuzzFace() {
   HarfBuzzFontCache::iterator result = GetHarfBuzzFontCache()->Find(unique_id_);
   SECURITY_DCHECK(result != GetHarfBuzzFontCache()->end());
-  ASSERT(result.Get()->value->RefCount() > 1);
+  DCHECK_GT(result.Get()->value->RefCount(), 1);
   result.Get()->value->Deref();
   if (result.Get()->value->RefCount() == 1)
     GetHarfBuzzFontCache()->erase(unique_id_);
 }
 
 static hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value) {
   // We treat HarfBuzz hb_position_t as 16.16 fixed-point.
   static const int kHbPosition1 = 1 << 16;
   return clampTo<int>(value * kHbPosition1);
 }
 
 static hb_bool_t HarfBuzzGetGlyph(hb_font_t* hb_font,
                                   void* font_data,
                                   hb_codepoint_t unicode,
                                   hb_codepoint_t variation_selector,
                                   hb_codepoint_t* glyph,
                                   void* user_data) {
   HarfBuzzFontData* hb_font_data =
       reinterpret_cast<HarfBuzzFontData*>(font_data);
 
-  RELEASE_ASSERT(hb_font_data);
+  CHECK(hb_font_data);
   if (hb_font_data->range_set_ && !hb_font_data->range_set_->Contains(unicode))
     return false;
 
   return hb_font_get_glyph(hb_font_get_parent(hb_font), unicode,
                            variation_selector, glyph);
 }
 
 static hb_position_t HarfBuzzGetGlyphHorizontalAdvance(hb_font_t* hb_font,
                                                        void* font_data,
                                                        hb_codepoint_t glyph,
@@ skipping 171 matching lines @@
 
   // Fallback to table copies if there is no in-memory access.
   if (!face) {
     face = hb_face_create_for_tables(HarfBuzzSkiaGetTable,
                                      platform_data_->Typeface(), 0);
     zero_copy_success_histogram.Count(false);
   } else {
     zero_copy_success_histogram.Count(true);
   }
 #endif
-  ASSERT(face);
+  DCHECK(face);
   return face;
 }
 
 PassRefPtr<HbFontCacheEntry> CreateHbFontCacheEntry(hb_face_t* face) {
   HbFontUniquePtr ot_font(hb_font_create(face));
   hb_ot_font_set_funcs(ot_font.get());
   // Creating a sub font means that non-available functions
   // are found from the parent.
   hb_font_t* unscaled_font = hb_font_create_sub_font(ot_font.get());
   RefPtr<HbFontCacheEntry> cache_entry =
@@ skipping 14 matching lines @@
     "Skia and HarfBuzz Variation parameter types must match in structure and "
     "size.");
 
 hb_font_t* HarfBuzzFace::GetScaledFont(
     PassRefPtr<UnicodeRangeSet> range_set) const {
   platform_data_->SetupPaint(&harf_buzz_font_data_->paint_);
   harf_buzz_font_data_->paint_.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   harf_buzz_font_data_->range_set_ = std::move(range_set);
   harf_buzz_font_data_->UpdateSimpleFontData(platform_data_);
 
-  ASSERT(harf_buzz_font_data_->simple_font_data_);
+  DCHECK(harf_buzz_font_data_->simple_font_data_);
   int scale = SkiaScalarToHarfBuzzPosition(platform_data_->size());
   hb_font_set_scale(unscaled_font_, scale, scale);
 
   SkTypeface* typeface = harf_buzz_font_data_->paint_.getTypeface();
   int axis_count = typeface->getVariationDesignPosition(nullptr, 0);
   if (axis_count > 0) {
     Vector<SkFontArguments::VariationPosition::Coordinate> axis_values;
     axis_values.Resize(axis_count);
     if (typeface->getVariationDesignPosition(axis_values.Data(),
                                              axis_values.size()) > 0) {
       hb_font_set_variations(
           unscaled_font_, reinterpret_cast<hb_variation_t*>(axis_values.Data()),
           axis_values.size());
     }
   }
 
   return unscaled_font_;
 }
 
 }  // namespace blink