Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

third_party/WebKit/Source/platform/graphics/ImageDecodingStore.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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 27 matching lines @@
 
 }  // namespace
 
 ImageDecodingStore::ImageDecodingStore()
     : heap_limit_in_bytes_(kDefaultMaxTotalSizeOfHeapEntries),
       heap_memory_usage_in_bytes_(0) {}
 
 ImageDecodingStore::~ImageDecodingStore() {
 #if DCHECK_IS_ON()
   SetCacheLimitInBytes(0);
-  ASSERT(!decoder_cache_map_.size());
-  ASSERT(!ordered_cache_list_.size());
-  ASSERT(!decoder_cache_key_map_.size());
+  DCHECK(!decoder_cache_map_.size());
+  DCHECK(!ordered_cache_list_.size());
+  DCHECK(!decoder_cache_key_map_.size());
 #endif
 }
 
 ImageDecodingStore& ImageDecodingStore::Instance() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(ImageDecodingStore, store,
                                   ImageDecodingStore::Create().release());
   return store;
 }
 
 bool ImageDecodingStore::LockDecoder(const ImageFrameGenerator* generator,
                                      const SkISize& scaled_size,
                                      ImageDecoder** decoder) {
-  ASSERT(decoder);
+  DCHECK(decoder);
 
   MutexLocker lock(mutex_);
   DecoderCacheMap::iterator iter = decoder_cache_map_.Find(
       DecoderCacheEntry::MakeCacheKey(generator, scaled_size));
   if (iter == decoder_cache_map_.end())
     return false;
 
   DecoderCacheEntry* cache_entry = iter->value.get();
 
   // There can only be one user of a decoder at a time.
-  ASSERT(!cache_entry->UseCount());
+  DCHECK(!cache_entry->UseCount());
   cache_entry->IncrementUseCount();
   *decoder = cache_entry->CachedDecoder();
   return true;
 }
 
 void ImageDecodingStore::UnlockDecoder(const ImageFrameGenerator* generator,
                                        const ImageDecoder* decoder) {
   MutexLocker lock(mutex_);
   DecoderCacheMap::iterator iter = decoder_cache_map_.Find(
       DecoderCacheEntry::MakeCacheKey(generator, decoder));
   SECURITY_DCHECK(iter != decoder_cache_map_.end());
 
   CacheEntry* cache_entry = iter->value.get();
   cache_entry->DecrementUseCount();
 
   // Put the entry to the end of list.
   ordered_cache_list_.Remove(cache_entry);
   ordered_cache_list_.Append(cache_entry);
 }
 
 void ImageDecodingStore::InsertDecoder(const ImageFrameGenerator* generator,
                                        std::unique_ptr<ImageDecoder> decoder) {
   // Prune old cache entries to give space for the new one.
   Prune();
 
   std::unique_ptr<DecoderCacheEntry> new_cache_entry =
       DecoderCacheEntry::Create(generator, std::move(decoder));
 
   MutexLocker lock(mutex_);
-  ASSERT(!decoder_cache_map_.Contains(new_cache_entry->CacheKey()));
+  DCHECK(!decoder_cache_map_.Contains(new_cache_entry->CacheKey()));
   InsertCacheInternal(std::move(new_cache_entry), &decoder_cache_map_,
                       &decoder_cache_key_map_);
 }
 
 void ImageDecodingStore::RemoveDecoder(const ImageFrameGenerator* generator,
                                        const ImageDecoder* decoder) {
   Vector<std::unique_ptr<CacheEntry>> cache_entries_to_delete;
   {
     MutexLocker lock(mutex_);
     DecoderCacheMap::iterator iter = decoder_cache_map_.Find(
         DecoderCacheEntry::MakeCacheKey(generator, decoder));
     SECURITY_DCHECK(iter != decoder_cache_map_.end());
 
     CacheEntry* cache_entry = iter->value.get();
-    ASSERT(cache_entry->UseCount());
+    DCHECK(cache_entry->UseCount());
     cache_entry->DecrementUseCount();
 
     // Delete only one decoder cache entry. Ownership of the cache entry
     // is transfered to cacheEntriesToDelete such that object can be deleted
     // outside of the lock.
     RemoveFromCacheInternal(cache_entry, &cache_entries_to_delete);
 
     // Remove from LRU list.
     RemoveFromCacheListInternal(cache_entries_to_delete);
   }
@@ skipping 105 matching lines @@
                  "ImageDecodingStoreNumOfDecoders", decoder_cache_map_.size());
 }
 
 template <class T, class U, class V>
 void ImageDecodingStore::RemoveFromCacheInternal(
     const T* cache_entry,
     U* cache_map,
     V* identifier_map,
     Vector<std::unique_ptr<CacheEntry>>* deletion_list) {
   const size_t cache_entry_bytes = cache_entry->MemoryUsageInBytes();
-  ASSERT(heap_memory_usage_in_bytes_ >= cache_entry_bytes);
+  DCHECK_GE(heap_memory_usage_in_bytes_, cache_entry_bytes);
   heap_memory_usage_in_bytes_ -= cache_entry_bytes;
 
   // Remove entry from identifier map.
   typename V::iterator iter = identifier_map->Find(cache_entry->Generator());
-  ASSERT(iter != identifier_map->end());
+  DCHECK(iter != identifier_map->end());
   iter->value.erase(cache_entry->CacheKey());
   if (!iter->value.size())
     identifier_map->erase(iter);
 
   // Remove entry from cache map.
   deletion_list->push_back(cache_map->Take(cache_entry->CacheKey()));
 
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"),
                  "ImageDecodingStoreHeapMemoryUsageBytes",
                  heap_memory_usage_in_bytes_);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"),
                  "ImageDecodingStoreNumOfDecoders", decoder_cache_map_.size());
 }
 
 void ImageDecodingStore::RemoveFromCacheInternal(
     const CacheEntry* cache_entry,
     Vector<std::unique_ptr<CacheEntry>>* deletion_list) {
   if (cache_entry->GetType() == CacheEntry::kTypeDecoder) {
     RemoveFromCacheInternal(static_cast<const DecoderCacheEntry*>(cache_entry),
                             &decoder_cache_map_, &decoder_cache_key_map_,
                             deletion_list);
   } else {
-    ASSERT(false);
+    DCHECK(false);
   }
 }
 
 template <class U, class V>
 void ImageDecodingStore::RemoveCacheIndexedByGeneratorInternal(
     U* cache_map,
     V* identifier_map,
     const ImageFrameGenerator* generator,
     Vector<std::unique_ptr<CacheEntry>>* deletion_list) {
   typename V::iterator iter = identifier_map->Find(generator);
   if (iter == identifier_map->end())
     return;
 
   // Get all cache identifiers associated with generator.
   Vector<typename U::KeyType> cache_identifier_list;
   CopyToVector(iter->value, cache_identifier_list);
 
   // For each cache identifier find the corresponding CacheEntry and remove it.
   for (size_t i = 0; i < cache_identifier_list.size(); ++i) {
-    ASSERT(cache_map->Contains(cache_identifier_list[i]));
+    DCHECK(cache_map->Contains(cache_identifier_list[i]));
     const auto& cache_entry = cache_map->at(cache_identifier_list[i]);
-    ASSERT(!cache_entry->UseCount());
+    DCHECK(!cache_entry->UseCount());
     RemoveFromCacheInternal(cache_entry, cache_map, identifier_map,
                             deletion_list);
   }
 }
 
 void ImageDecodingStore::RemoveFromCacheListInternal(
     const Vector<std::unique_ptr<CacheEntry>>& deletion_list) {
   for (size_t i = 0; i < deletion_list.size(); ++i)
     ordered_cache_list_.Remove(deletion_list[i].get());
 }
 
 }  // namespace blink