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 205 matching lines @@
   FallbackListShaperCache::iterator it =
       g_fallback_list_shaper_cache->Find(key);
   ShapeCache* result = nullptr;
   if (it == g_fallback_list_shaper_cache->end()) {
     result = new ShapeCache();
     g_fallback_list_shaper_cache->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 49 matching lines @@
 
 PassRefPtr<SimpleFontData> FontCache::FontDataFromFontPlatformData(
     const FontPlatformData* platform_data,
     ShouldRetain should_retain,
     bool subpixel_ascent_descent) {
   if (!g_font_data_cache)
     g_font_data_cache = new FontDataCache;
 
 #if DCHECK_IS_ON()
   if (should_retain == kDoNotRetain)
-    ASSERT(purge_prevent_count_);
+    DCHECK(purge_prevent_count_);
 #endif
 
   return g_font_data_cache->Get(platform_data, should_retain,
                                 subpixel_ascent_descent);
 }
 
 bool FontCache::IsPlatformFamilyMatchAvailable(
     const FontDescription& font_description,
     const AtomicString& family) {
   return GetFontPlatformData(
@@ skipping 18 matching lines @@
   return String::FromUTF8(
       gfx::FontList::FirstAvailableOrFirst(families.Utf8().Data()).c_str());
 }
 
 SimpleFontData* FontCache::GetNonRetainedLastResortFallbackFont(
     const FontDescription& font_description) {
   return GetLastResortFallbackFont(font_description, kDoNotRetain).LeakRef();
 }
 
 void FontCache::ReleaseFontData(const SimpleFontData* font_data) {
-  ASSERT(g_font_data_cache);
+  DCHECK(g_font_data_cache);
 
   g_font_data_cache->Release(font_data);
 }
 
 static inline void PurgePlatformFontDataCache() {
   if (!g_font_platform_data_cache)
     return;
 
   Vector<FontCacheKey> keys_to_remove;
   keys_to_remove.ReserveInitialCapacity(g_font_platform_data_cache->size());
@@ skipping 78 matching lines @@
 
 HeapHashSet<WeakMember<FontCacheClient>>& FontCacheClients() {
   DEFINE_STATIC_LOCAL(HeapHashSet<WeakMember<FontCacheClient>>, clients,
                       (new HeapHashSet<WeakMember<FontCacheClient>>));
   g_invalidate_font_cache = true;
   return clients;
 }
 
 void FontCache::AddClient(FontCacheClient* client) {
   CHECK(client);
-  ASSERT(!FontCacheClients().Contains(client));
+  DCHECK(!FontCacheClients().Contains(client));
   FontCacheClients().insert(client);
 }
 
 static unsigned short g_generation = 0;
 
 unsigned short FontCache::Generation() {
   return g_generation;
 }
 
 void FontCache::Invalidate() {
   if (!g_invalidate_font_cache) {
-    ASSERT(!g_font_platform_data_cache);
+    DCHECK(!g_font_platform_data_cache);
     return;
   }
 
   if (g_font_platform_data_cache) {
     delete g_font_platform_data_cache;
     g_font_platform_data_cache = new FontPlatformDataCache;
   }
 
   g_generation++;
 
@@ skipping 20 matching lines @@
 
   debug::Alias(&font_cache);
   debug::Alias(&font_mgr);
   debug::Alias(&num_families);
 
   CHECK(false);
 }
 
 void FontCache::DumpFontPlatformDataCache(
     base::trace_event::ProcessMemoryDump* memory_dump) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   if (!g_font_platform_data_cache)
     return;
   base::trace_event::MemoryAllocatorDump* dump =
       memory_dump->CreateAllocatorDump("font_caches/font_platform_data_cache");
   size_t font_platform_data_objects_size =
       g_font_platform_data_cache->size() * sizeof(FontPlatformData);
   dump->AddScalar("size", "bytes", font_platform_data_objects_size);
   memory_dump->AddSuballocation(dump->guid(),
                                 WTF::Partitions::kAllocatedObjectPoolName);
 }
 
 void FontCache::DumpShapeResultCache(
     base::trace_event::ProcessMemoryDump* memory_dump) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   if (!g_fallback_list_shaper_cache) {
     return;
   }
   base::trace_event::MemoryAllocatorDump* dump =
       memory_dump->CreateAllocatorDump("font_caches/shape_caches");
   size_t shape_result_cache_size = 0;
   FallbackListShaperCache::iterator iter;
   for (iter = g_fallback_list_shaper_cache->begin();
        iter != g_fallback_list_shaper_cache->end(); ++iter) {
     shape_result_cache_size += iter->value->ByteSize();
   }
   dump->AddScalar("size", "bytes", shape_result_cache_size);
   memory_dump->AddSuballocation(dump->guid(),
                                 WTF::Partitions::kAllocatedObjectPoolName);
 }
 
 }  // namespace blink