Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/fonts

third_party/WebKit/Source/platform/fonts/FontCache.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  *
  * 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.
@@ skipping 203 matching lines @@
 
   FallbackListShaperCache::iterator it = gFallbackListShaperCache->find(key);
   ShapeCache* result = nullptr;
   if (it == gFallbackListShaperCache->end()) {
     result = new ShapeCache();
     gFallbackListShaperCache->set(key, WTF::wrapUnique(result));
   } else {
     result = it->value.get();
   }
 
-  ASSERT(result);
+  DCHECK(result);
   return result;
 }
 
 typedef HashMap<FontCache::FontFileKey,
                 RefPtr<OpenTypeVerticalData>,
                 IntHash<FontCache::FontFileKey>,
                 UnsignedWithZeroKeyHashTraits<FontCache::FontFileKey>>
     FontVerticalDataCache;
 
 FontVerticalDataCache& fontVerticalDataCacheInstance() {
@@ skipping 48 matching lines @@
 
 PassRefPtr<SimpleFontData> FontCache::fontDataFromFontPlatformData(
     const FontPlatformData* platformData,
     ShouldRetain shouldRetain,
     bool subpixelAscentDescent) {
   if (!gFontDataCache)
     gFontDataCache = new FontDataCache;
 
 #if DCHECK_IS_ON()
   if (shouldRetain == DoNotRetain)
-    ASSERT(m_purgePreventCount);
+    DCHECK(m_purgePreventCount);
 #endif
 
   return gFontDataCache->get(platformData, shouldRetain, subpixelAscentDescent);
 }
 
 bool FontCache::isPlatformFamilyMatchAvailable(
     const FontDescription& fontDescription,
     const AtomicString& family) {
   return getFontPlatformData(
       fontDescription,
@@ skipping 17 matching lines @@
   return String::fromUTF8(
       gfx::FontList::FirstAvailableOrFirst(families.utf8().data()).c_str());
 }
 
 SimpleFontData* FontCache::getNonRetainedLastResortFallbackFont(
     const FontDescription& fontDescription) {
   return getLastResortFallbackFont(fontDescription, DoNotRetain).leakRef();
 }
 
 void FontCache::releaseFontData(const SimpleFontData* fontData) {
-  ASSERT(gFontDataCache);
+  DCHECK(gFontDataCache);
 
   gFontDataCache->release(fontData);
 }
 
 static inline void purgePlatformFontDataCache() {
   if (!gFontPlatformDataCache)
     return;
 
   Vector<FontCacheKey> keysToRemove;
   keysToRemove.reserveInitialCapacity(gFontPlatformDataCache->size());
@@ skipping 78 matching lines @@
 
 HeapHashSet<WeakMember<FontCacheClient>>& fontCacheClients() {
   DEFINE_STATIC_LOCAL(HeapHashSet<WeakMember<FontCacheClient>>, clients,
                       (new HeapHashSet<WeakMember<FontCacheClient>>));
   invalidateFontCache = true;
   return clients;
 }
 
 void FontCache::addClient(FontCacheClient* client) {
   CHECK(client);
-  ASSERT(!fontCacheClients().contains(client));
+  DCHECK(!fontCacheClients().contains(client));
   fontCacheClients().insert(client);
 }
 
 static unsigned short gGeneration = 0;
 
 unsigned short FontCache::generation() {
   return gGeneration;
 }
 
 void FontCache::invalidate() {
   if (!invalidateFontCache) {
-    ASSERT(!gFontPlatformDataCache);
+    DCHECK(!gFontPlatformDataCache);
     return;
   }
 
   if (gFontPlatformDataCache) {
     delete gFontPlatformDataCache;
     gFontPlatformDataCache = new FontPlatformDataCache;
   }
 
   gGeneration++;
 
@@ skipping 20 matching lines @@
 
   debug::alias(&fontCache);
   debug::alias(&fontMgr);
   debug::alias(&numFamilies);
 
   CHECK(false);
 }
 
 void FontCache::dumpFontPlatformDataCache(
     base::trace_event::ProcessMemoryDump* memoryDump) {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   if (!gFontPlatformDataCache)
     return;
   base::trace_event::MemoryAllocatorDump* dump =
       memoryDump->CreateAllocatorDump("font_caches/font_platform_data_cache");
   size_t fontPlatformDataObjectsSize =
       gFontPlatformDataCache->size() * sizeof(FontPlatformData);
   dump->AddScalar("size", "bytes", fontPlatformDataObjectsSize);
   memoryDump->AddSuballocation(dump->guid(),
                                WTF::Partitions::kAllocatedObjectPoolName);
 }
 
 void FontCache::dumpShapeResultCache(
     base::trace_event::ProcessMemoryDump* memoryDump) {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   if (!gFallbackListShaperCache) {
     return;
   }
   base::trace_event::MemoryAllocatorDump* dump =
       memoryDump->CreateAllocatorDump("font_caches/shape_caches");
   size_t shapeResultCacheSize = 0;
   FallbackListShaperCache::iterator iter;
   for (iter = gFallbackListShaperCache->begin();
        iter != gFallbackListShaperCache->end(); ++iter) {
     shapeResultCacheSize += iter->value->byteSize();
   }
   dump->AddScalar("size", "bytes", shapeResultCacheSize);
   memoryDump->AddSuballocation(dump->guid(),
                                WTF::Partitions::kAllocatedObjectPoolName);
 }
 
 }  // namespace blink