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()
     : m_heapLimitInBytes(defaultMaxTotalSizeOfHeapEntries),
       m_heapMemoryUsageInBytes(0) {}
 
 ImageDecodingStore::~ImageDecodingStore() {
 #if DCHECK_IS_ON()
   setCacheLimitInBytes(0);
-  ASSERT(!m_decoderCacheMap.size());
-  ASSERT(!m_orderedCacheList.size());
-  ASSERT(!m_decoderCacheKeyMap.size());
+  DCHECK(!m_decoderCacheMap.size());
+  DCHECK(!m_orderedCacheList.size());
+  DCHECK(!m_decoderCacheKeyMap.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& scaledSize,
                                      ImageDecoder** decoder) {
-  ASSERT(decoder);
+  DCHECK(decoder);
 
   MutexLocker lock(m_mutex);
   DecoderCacheMap::iterator iter = m_decoderCacheMap.find(
       DecoderCacheEntry::makeCacheKey(generator, scaledSize));
   if (iter == m_decoderCacheMap.end())
     return false;
 
   DecoderCacheEntry* cacheEntry = iter->value.get();
 
   // There can only be one user of a decoder at a time.
-  ASSERT(!cacheEntry->useCount());
+  DCHECK(!cacheEntry->useCount());
   cacheEntry->incrementUseCount();
   *decoder = cacheEntry->cachedDecoder();
   return true;
 }
 
 void ImageDecodingStore::unlockDecoder(const ImageFrameGenerator* generator,
                                        const ImageDecoder* decoder) {
   MutexLocker lock(m_mutex);
   DecoderCacheMap::iterator iter = m_decoderCacheMap.find(
       DecoderCacheEntry::makeCacheKey(generator, decoder));
   SECURITY_DCHECK(iter != m_decoderCacheMap.end());
 
   CacheEntry* cacheEntry = iter->value.get();
   cacheEntry->decrementUseCount();
 
   // Put the entry to the end of list.
   m_orderedCacheList.remove(cacheEntry);
   m_orderedCacheList.append(cacheEntry);
 }
 
 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> newCacheEntry =
       DecoderCacheEntry::create(generator, std::move(decoder));
 
   MutexLocker lock(m_mutex);
-  ASSERT(!m_decoderCacheMap.contains(newCacheEntry->cacheKey()));
+  DCHECK(!m_decoderCacheMap.contains(newCacheEntry->cacheKey()));
   insertCacheInternal(std::move(newCacheEntry), &m_decoderCacheMap,
                       &m_decoderCacheKeyMap);
 }
 
 void ImageDecodingStore::removeDecoder(const ImageFrameGenerator* generator,
                                        const ImageDecoder* decoder) {
   Vector<std::unique_ptr<CacheEntry>> cacheEntriesToDelete;
   {
     MutexLocker lock(m_mutex);
     DecoderCacheMap::iterator iter = m_decoderCacheMap.find(
         DecoderCacheEntry::makeCacheKey(generator, decoder));
     SECURITY_DCHECK(iter != m_decoderCacheMap.end());
 
     CacheEntry* cacheEntry = iter->value.get();
-    ASSERT(cacheEntry->useCount());
+    DCHECK(cacheEntry->useCount());
     cacheEntry->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(cacheEntry, &cacheEntriesToDelete);
 
     // Remove from LRU list.
     removeFromCacheListInternal(cacheEntriesToDelete);
   }
@@ skipping 104 matching lines @@
                  "ImageDecodingStoreNumOfDecoders", m_decoderCacheMap.size());
 }
 
 template <class T, class U, class V>
 void ImageDecodingStore::removeFromCacheInternal(
     const T* cacheEntry,
     U* cacheMap,
     V* identifierMap,
     Vector<std::unique_ptr<CacheEntry>>* deletionList) {
   const size_t cacheEntryBytes = cacheEntry->memoryUsageInBytes();
-  ASSERT(m_heapMemoryUsageInBytes >= cacheEntryBytes);
+  DCHECK_GE(m_heapMemoryUsageInBytes, cacheEntryBytes);
   m_heapMemoryUsageInBytes -= cacheEntryBytes;
 
   // Remove entry from identifier map.
   typename V::iterator iter = identifierMap->find(cacheEntry->generator());
-  ASSERT(iter != identifierMap->end());
+  DCHECK_NE(iter, identifierMap->end());
   iter->value.erase(cacheEntry->cacheKey());
   if (!iter->value.size())
     identifierMap->erase(iter);
 
   // Remove entry from cache map.
   deletionList->push_back(cacheMap->take(cacheEntry->cacheKey()));
 
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"),
                  "ImageDecodingStoreHeapMemoryUsageBytes",
                  m_heapMemoryUsageInBytes);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.image_decoding"),
                  "ImageDecodingStoreNumOfDecoders", m_decoderCacheMap.size());
 }
 
 void ImageDecodingStore::removeFromCacheInternal(
     const CacheEntry* cacheEntry,
     Vector<std::unique_ptr<CacheEntry>>* deletionList) {
   if (cacheEntry->type() == CacheEntry::TypeDecoder) {
     removeFromCacheInternal(static_cast<const DecoderCacheEntry*>(cacheEntry),
                             &m_decoderCacheMap, &m_decoderCacheKeyMap,
                             deletionList);
   } else {
-    ASSERT(false);
+    DCHECK(false);
   }
 }
 
 template <class U, class V>
 void ImageDecodingStore::removeCacheIndexedByGeneratorInternal(
     U* cacheMap,
     V* identifierMap,
     const ImageFrameGenerator* generator,
     Vector<std::unique_ptr<CacheEntry>>* deletionList) {
   typename V::iterator iter = identifierMap->find(generator);
   if (iter == identifierMap->end())
     return;
 
   // Get all cache identifiers associated with generator.
   Vector<typename U::KeyType> cacheIdentifierList;
   copyToVector(iter->value, cacheIdentifierList);
 
   // For each cache identifier find the corresponding CacheEntry and remove it.
   for (size_t i = 0; i < cacheIdentifierList.size(); ++i) {
-    ASSERT(cacheMap->contains(cacheIdentifierList[i]));
+    DCHECK(cacheMap->contains(cacheIdentifierList[i]));
     const auto& cacheEntry = cacheMap->at(cacheIdentifierList[i]);
-    ASSERT(!cacheEntry->useCount());
+    DCHECK(!cacheEntry->useCount());
     removeFromCacheInternal(cacheEntry, cacheMap, identifierMap, deletionList);
   }
 }
 
 void ImageDecodingStore::removeFromCacheListInternal(
     const Vector<std::unique_ptr<CacheEntry>>& deletionList) {
   for (size_t i = 0; i < deletionList.size(); ++i)
     m_orderedCacheList.remove(deletionList[i].get());
 }
 
 }  // namespace blink