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* hbFont) {
-    ASSERT(hbFont);
+    DCHECK(hbFont);
     return adoptRef(new HbFontCacheEntry(hbFont));
   }
 
   hb_font_t* hbFont() { return m_hbFont.get(); }
   HarfBuzzFontData* hbFontData() { return m_hbFontData.get(); }
 
  private:
   explicit HbFontCacheEntry(hb_font_t* font)
       : m_hbFont(HbFontUniquePtr(font)),
         m_hbFontData(WTF::makeUnique<HarfBuzzFontData>()){};
@@ skipping 24 matching lines @@
     result.storedValue->value = createHbFontCacheEntry(face.get());
   }
   result.storedValue->value->ref();
   m_unscaledFont = result.storedValue->value->hbFont();
   m_harfBuzzFontData = result.storedValue->value->hbFontData();
 }
 
 HarfBuzzFace::~HarfBuzzFace() {
   HarfBuzzFontCache::iterator result = harfBuzzFontCache()->find(m_uniqueID);
   SECURITY_DCHECK(result != harfBuzzFontCache()->end());
-  ASSERT(result.get()->value->refCount() > 1);
+  DCHECK_GT(result.get()->value->refCount(), 1);
   result.get()->value->deref();
   if (result.get()->value->refCount() == 1)
     harfBuzzFontCache()->erase(m_uniqueID);
 }
 
 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* hbFont,
                                   void* fontData,
                                   hb_codepoint_t unicode,
                                   hb_codepoint_t variationSelector,
                                   hb_codepoint_t* glyph,
                                   void* userData) {
   HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
 
-  RELEASE_ASSERT(hbFontData);
+  CHECK(hbFontData);
   if (hbFontData->m_rangeSet && !hbFontData->m_rangeSet->contains(unicode))
     return false;
 
   return hb_font_get_glyph(hb_font_get_parent(hbFont), unicode,
                            variationSelector, glyph);
 }
 
 static hb_position_t harfBuzzGetGlyphHorizontalAdvance(hb_font_t* hbFont,
                                                        void* fontData,
                                                        hb_codepoint_t glyph,
@@ skipping 164 matching lines @@
 
   // Fallback to table copies if there is no in-memory access.
   if (!face) {
     face = hb_face_create_for_tables(harfBuzzSkiaGetTable,
                                      m_platformData->typeface(), 0);
     zeroCopySuccessHistogram.count(false);
   } else {
     zeroCopySuccessHistogram.count(true);
   }
 #endif
-  ASSERT(face);
+  DCHECK(face);
   return face;
 }
 
 PassRefPtr<HbFontCacheEntry> createHbFontCacheEntry(hb_face_t* face) {
   HbFontUniquePtr otFont(hb_font_create(face));
   hb_ot_font_set_funcs(otFont.get());
   // Creating a sub font means that non-available functions
   // are found from the parent.
   hb_font_t* unscaledFont = hb_font_create_sub_font(otFont.get());
   RefPtr<HbFontCacheEntry> cacheEntry = HbFontCacheEntry::create(unscaledFont);
@@ skipping 13 matching lines @@
     "Skia and HarfBuzz Variation parameter types must match in structure and "
     "size.");
 
 hb_font_t* HarfBuzzFace::getScaledFont(
     PassRefPtr<UnicodeRangeSet> rangeSet) const {
   m_platformData->setupPaint(&m_harfBuzzFontData->m_paint);
   m_harfBuzzFontData->m_paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   m_harfBuzzFontData->m_rangeSet = std::move(rangeSet);
   m_harfBuzzFontData->updateSimpleFontData(m_platformData);
 
-  ASSERT(m_harfBuzzFontData->m_simpleFontData);
+  DCHECK(m_harfBuzzFontData->m_simpleFontData);
   int scale = SkiaScalarToHarfBuzzPosition(m_platformData->size());
   hb_font_set_scale(m_unscaledFont, scale, scale);
 
   SkTypeface* typeface = m_harfBuzzFontData->m_paint.getTypeface();
   int axisCount = typeface->getVariationDesignPosition(nullptr, 0);
   if (axisCount > 0) {
     Vector<SkFontArguments::VariationPosition::Coordinate> axisValues;
     axisValues.resize(axisCount);
     if (typeface->getVariationDesignPosition(axisValues.data(),
                                              axisValues.size()) > 0) {
       hb_font_set_variations(
           m_unscaledFont, reinterpret_cast<hb_variation_t*>(axisValues.data()),
           axisValues.size());
     }
   }
 
   return m_unscaledFont;
 }
 
 }  // namespace blink