Replace ASSERT*() with DCHECK*() in core/fetch/ and core/loader/

third_party/WebKit/Source/core/fetch/MemoryCache.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 27 matching lines @@
 static Persistent<MemoryCache>* gMemoryCache;
 
 static const unsigned cDefaultCacheCapacity = 8192 * 1024;
 static const unsigned cDeferredPruneDeadCapacityFactor = 2;
 static const int cMinDelayBeforeLiveDecodedPrune = 1; // Seconds.
 static const double cMaxPruneDeferralDelay = 0.5; // Seconds.
 static const float cTargetPrunePercentage = .95f; // Percentage of capacity toward which we prune, to avoid immediately pruning again.
 
 MemoryCache* memoryCache()
 {
-    ASSERT(WTF::isMainThread());
+    DCHECK(WTF::isMainThread());
     if (!gMemoryCache)
         gMemoryCache = new Persistent<MemoryCache>(MemoryCache::create());
     return gMemoryCache->get();
 }
 
 MemoryCache* replaceMemoryCacheForTesting(MemoryCache* cache)
 {
     memoryCache();
     MemoryCache* oldCache = gMemoryCache->release();
     *gMemoryCache = cache;
@@ skipping 90 matching lines @@
 
 String MemoryCache::defaultCacheIdentifier()
 {
     return emptyString();
 }
 
 MemoryCache::ResourceMap* MemoryCache::ensureResourceMap(const String& cacheIdentifier)
 {
     if (!m_resourceMaps.contains(cacheIdentifier)) {
         ResourceMapIndex::AddResult result = m_resourceMaps.add(cacheIdentifier, new ResourceMap);
-        RELEASE_ASSERT(result.isNewEntry);
+        CHECK(result.isNewEntry);
     }
     return m_resourceMaps.get(cacheIdentifier);
 }
 
 void MemoryCache::add(Resource* resource)
 {
-    ASSERT(WTF::isMainThread());
-    ASSERT(resource->url().isValid());
+    DCHECK(WTF::isMainThread());
+    DCHECK(resource->url().isValid());
     ResourceMap* resources = ensureResourceMap(resource->cacheIdentifier());
     KURL url = removeFragmentIdentifierIfNeeded(resource->url());
     CHECK(!contains(resource));
     resources->set(url, MemoryCacheEntry::create(resource));
     update(resource, 0, resource->size(), true);
 
     RESOURCE_LOADING_DVLOG(1) << "MemoryCache::add Added " << resource->url().getString() << ", resource " << resource;
 }
 
 void MemoryCache::remove(Resource* resource)
 {
     // The resource may have already been removed by someone other than our caller,
     // who needed a fresh copy for a reload.
     if (MemoryCacheEntry* entry = getEntryForResource(resource))
         evict(entry);
 }
 
 bool MemoryCache::contains(const Resource* resource) const
 {
     return getEntryForResource(resource);
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL)
 {
     return resourceForURL(resourceURL, defaultCacheIdentifier());
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL, const String& cacheIdentifier)
 {
-    ASSERT(WTF::isMainThread());
+    DCHECK(WTF::isMainThread());
     if (!resourceURL.isValid() || resourceURL.isNull())
         return nullptr;
-    ASSERT(!cacheIdentifier.isNull());
+    DCHECK(!cacheIdentifier.isNull());
     ResourceMap* resources = m_resourceMaps.get(cacheIdentifier);
     if (!resources)
         return nullptr;
     KURL url = removeFragmentIdentifierIfNeeded(resourceURL);
     MemoryCacheEntry* entry = resources->get(url);
     if (!entry)
         return nullptr;
     return entry->resource();
 }
 
 HeapVector<Member<Resource>> MemoryCache::resourcesForURL(const KURL& resourceURL)
 {
-    ASSERT(WTF::isMainThread());
+    DCHECK(WTF::isMainThread());
     KURL url = removeFragmentIdentifierIfNeeded(resourceURL);
     HeapVector<Member<Resource>> results;
     for (const auto& resourceMapIter : m_resourceMaps) {
         if (MemoryCacheEntry* entry = resourceMapIter.value->get(url)) {
             Resource* resource = entry->resource();
             DCHECK(resource);
             results.append(resource);
         }
     }
     return results;
 }
 
 size_t MemoryCache::deadCapacity() const
 {
     // Dead resource capacity is whatever space is not occupied by live resources, bounded by an independent minimum and maximum.
     size_t capacity = m_capacity - std::min(m_liveSize, m_capacity); // Start with available capacity.
     capacity = std::max(capacity, m_minDeadCapacity); // Make sure it's above the minimum.
     capacity = std::min(capacity, m_maxDeadCapacity); // Make sure it's below the maximum.
     return capacity;
 }
 
 size_t MemoryCache::liveCapacity() const
 {
     // Live resource capacity is whatever is left over after calculating dead resource capacity.
     return m_capacity - deadCapacity();
 }
 
 void MemoryCache::pruneLiveResources(PruneStrategy strategy)
 {
-    ASSERT(!m_prunePending);
+    DCHECK(!m_prunePending);
     size_t capacity = liveCapacity();
     if (strategy == MaximalPrune)
         capacity = 0;
     if (!m_liveSize || (capacity && m_liveSize <= capacity))
         return;
 
     size_t targetSize = static_cast<size_t>(capacity * cTargetPrunePercentage); // Cut by a percentage to avoid immediately pruning again.
 
     // Destroy any decoded data in live objects that we can.
     // Start from the tail, since this is the lowest priority
@@ skipping 94 matching lines @@
         // empty LRU lists on future prunes.
         if (m_allResources[i].m_head)
             canShrinkLRULists = false;
         else if (canShrinkLRULists)
             m_allResources.resize(i);
     }
 }
 
 void MemoryCache::setCapacities(size_t minDeadBytes, size_t maxDeadBytes, size_t totalBytes)
 {
-    ASSERT(minDeadBytes <= maxDeadBytes);
-    ASSERT(maxDeadBytes <= totalBytes);
+    DCHECK_LE(minDeadBytes, maxDeadBytes);
+    DCHECK_LE(maxDeadBytes, totalBytes);
     m_minDeadCapacity = minDeadBytes;
     m_maxDeadCapacity = maxDeadBytes;
     m_maxDeferredPruneDeadCapacity = cDeferredPruneDeadCapacityFactor * maxDeadBytes;
     m_capacity = totalBytes;
     prune();
 }
 
 void MemoryCache::evict(MemoryCacheEntry* entry)
 {
-    ASSERT(WTF::isMainThread());
+    DCHECK(WTF::isMainThread());
 
     Resource* resource = entry->resource();
     DCHECK(resource);
     RESOURCE_LOADING_DVLOG(1) << "Evicting resource " << resource << " for " << resource->url().getString() << " from cache";
     TRACE_EVENT1("blink", "MemoryCache::evict", "resource", resource->url().getString().utf8());
     // The resource may have already been removed by someone other than our caller,
     // who needed a fresh copy for a reload. See <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>.
     update(resource, resource->size(), 0, false);
     removeFromLiveDecodedResourcesList(entry);
 
     ResourceMap* resources = m_resourceMaps.get(resource->cacheIdentifier());
-    ASSERT(resources);
+    DCHECK(resources);
     KURL url = removeFragmentIdentifierIfNeeded(resource->url());
     ResourceMap::iterator it = resources->find(url);
-    ASSERT(it != resources->end());
+    DCHECK_NE(it, resources->end());
 
     MemoryCacheEntry* entryPtr = it->value;
     resources->remove(it);
     if (entryPtr)
         entryPtr->dispose();
 }
 
 MemoryCacheEntry* MemoryCache::getEntryForResource(const Resource* resource) const
 {
     if (!resource || resource->url().isNull() || resource->url().isEmpty())
         return nullptr;
     ResourceMap* resources = m_resourceMaps.get(resource->cacheIdentifier());
     if (!resources)
         return nullptr;
     KURL url = removeFragmentIdentifierIfNeeded(resource->url());
     MemoryCacheEntry* entry = resources->get(url);
     if (!entry || entry->resource() != resource)
         return nullptr;
     return entry;
 }
 
 MemoryCacheLRUList* MemoryCache::lruListFor(unsigned accessCount, size_t size)
 {
-    ASSERT(accessCount > 0);
+    DCHECK_GT(accessCount, 0u);
     unsigned queueIndex = WTF::fastLog2(size / accessCount);
     if (m_allResources.size() <= queueIndex)
         m_allResources.grow(queueIndex + 1);
     return &m_allResources[queueIndex];
 }
 
 void MemoryCache::removeFromLRUList(MemoryCacheEntry* entry, MemoryCacheLRUList* list)
 {
-    ASSERT(containedInLRUList(entry, list));
+    DCHECK(containedInLRUList(entry, list));
 
     MemoryCacheEntry* next = entry->m_nextInAllResourcesList;
     MemoryCacheEntry* previous = entry->m_previousInAllResourcesList;
     entry->m_nextInAllResourcesList = nullptr;
     entry->m_previousInAllResourcesList = nullptr;
 
     if (next)
         next->m_previousInAllResourcesList = previous;
     else
         list->m_tail = previous;
 
     if (previous)
         previous->m_nextInAllResourcesList = next;
     else
         list->m_head = next;
 
-    ASSERT(!containedInLRUList(entry, list));
+    DCHECK(!containedInLRUList(entry, list));
 }
 
 void MemoryCache::insertInLRUList(MemoryCacheEntry* entry, MemoryCacheLRUList* list)
 {
-    ASSERT(!containedInLRUList(entry, list));
+    DCHECK(!containedInLRUList(entry, list));
 
     entry->m_nextInAllResourcesList = list->m_head;
     list->m_head = entry;
 
     if (entry->m_nextInAllResourcesList)
         entry->m_nextInAllResourcesList->m_previousInAllResourcesList = entry;
     else
         list->m_tail = entry;
 
-    ASSERT(containedInLRUList(entry, list));
+    DCHECK(containedInLRUList(entry, list));
 }
 
 bool MemoryCache::containedInLRUList(MemoryCacheEntry* entry, MemoryCacheLRUList* list)
 {
     for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
         if (current == entry)
             return true;
     }
-    ASSERT(!entry->m_nextInAllResourcesList && !entry->m_previousInAllResourcesList);
+    DCHECK(!entry->m_nextInAllResourcesList);
+    DCHECK(!entry->m_previousInAllResourcesList);
     return false;
 }
 
 void MemoryCache::removeFromLiveDecodedResourcesList(MemoryCacheEntry* entry)
 {
     // If we've never been accessed, then we're brand new and not in any list.
     if (!entry->m_inLiveDecodedResourcesList)
         return;
-    ASSERT(containedInLiveDecodedResourcesList(entry));
+    DCHECK(containedInLiveDecodedResourcesList(entry));
 
     entry->m_inLiveDecodedResourcesList = false;
 
     MemoryCacheEntry* next = entry->m_nextInLiveResourcesList;
     MemoryCacheEntry* previous = entry->m_previousInLiveResourcesList;
 
     entry->m_nextInLiveResourcesList = nullptr;
     entry->m_previousInLiveResourcesList = nullptr;
 
     if (next)
         next->m_previousInLiveResourcesList = previous;
     else
         m_liveDecodedResources.m_tail = previous;
 
     if (previous)
         previous->m_nextInLiveResourcesList = next;
     else
         m_liveDecodedResources.m_head = next;
 
-    ASSERT(!containedInLiveDecodedResourcesList(entry));
+    DCHECK(!containedInLiveDecodedResourcesList(entry));
 }
 
 void MemoryCache::insertInLiveDecodedResourcesList(MemoryCacheEntry* entry)
 {
-    ASSERT(!containedInLiveDecodedResourcesList(entry));
+    DCHECK(!containedInLiveDecodedResourcesList(entry));
 
     entry->m_inLiveDecodedResourcesList = true;
 
     entry->m_nextInLiveResourcesList = m_liveDecodedResources.m_head;
     if (m_liveDecodedResources.m_head)
         m_liveDecodedResources.m_head->m_previousInLiveResourcesList = entry;
     m_liveDecodedResources.m_head = entry;
 
     if (!entry->m_nextInLiveResourcesList)
         m_liveDecodedResources.m_tail = entry;
 
-    ASSERT(containedInLiveDecodedResourcesList(entry));
+    DCHECK(containedInLiveDecodedResourcesList(entry));
 }
 
 bool MemoryCache::containedInLiveDecodedResourcesList(MemoryCacheEntry* entry)
 {
     for (MemoryCacheEntry* current = m_liveDecodedResources.m_head; current; current = current->m_nextInLiveResourcesList) {
         if (current == entry) {
-            ASSERT(entry->m_inLiveDecodedResourcesList);
+            DCHECK(entry->m_inLiveDecodedResourcesList);
             return true;
         }
     }
-    ASSERT(!entry->m_nextInLiveResourcesList && !entry->m_previousInLiveResourcesList && !entry->m_inLiveDecodedResourcesList);
+    DCHECK(!entry->m_nextInLiveResourcesList);
+    DCHECK(!entry->m_previousInLiveResourcesList);
+    DCHECK(!entry->m_inLiveDecodedResourcesList);
     return false;
 }
 
 void MemoryCache::makeLive(Resource* resource)
 {
     if (!contains(resource))
         return;
-    ASSERT(m_deadSize >= resource->size());
+    DCHECK_GE(m_deadSize, resource->size());
     m_liveSize += resource->size();
     m_deadSize -= resource->size();
 }
 
 void MemoryCache::makeDead(Resource* resource)
 {
     if (!contains(resource))
         return;
     m_liveSize -= resource->size();
     m_deadSize += resource->size();
@@ skipping 10 matching lines @@
     // and both of those are used to determine which LRU queue the resource should be in.
     if (oldSize)
         removeFromLRUList(entry, lruListFor(entry->m_accessCount, oldSize));
     if (wasAccessed)
         entry->m_accessCount++;
     if (newSize)
         insertInLRUList(entry, lruListFor(entry->m_accessCount, newSize));
 
     ptrdiff_t delta = newSize - oldSize;
     if (resource->isAlive()) {
-        ASSERT(delta >= 0 || m_liveSize >= static_cast<size_t>(-delta) );
+        DCHECK(delta >= 0 || m_liveSize >= static_cast<size_t>(-delta) );
         m_liveSize += delta;
     } else {
-        ASSERT(delta >= 0 || m_deadSize >= static_cast<size_t>(-delta) );
+        DCHECK(delta >= 0 || m_deadSize >= static_cast<size_t>(-delta) );
         m_deadSize += delta;
     }
 }
 
 void MemoryCache::updateDecodedResource(Resource* resource, UpdateReason reason)
 {
     MemoryCacheEntry* entry = getEntryForResource(resource);
     if (!entry)
         return;
 
@@ skipping 123 matching lines @@
     }
 }
 
 void MemoryCache::willProcessTask()
 {
 }
 
 void MemoryCache::didProcessTask()
 {
     // Perform deferred pruning
-    ASSERT(m_prunePending);
+    DCHECK(m_prunePending);
     pruneNow(WTF::currentTime(), AutomaticPrune);
 }
 
 void MemoryCache::pruneAll()
 {
     double currentTime = WTF::currentTime();
     pruneNow(currentTime, MaximalPrune);
 }
 
 void MemoryCache::pruneNow(double currentTime, PruneStrategy strategy)
@@ skipping 28 matching lines @@
 
 void MemoryCache::onMemoryPressure(WebMemoryPressureLevel level)
 {
     pruneAll();
 }
 
 bool MemoryCache::isInSameLRUListForTest(const Resource* x, const Resource* y)
 {
     MemoryCacheEntry* ex = getEntryForResource(x);
     MemoryCacheEntry* ey = getEntryForResource(y);
-    ASSERT(ex);
-    ASSERT(ey);
+    DCHECK(ex);
+    DCHECK(ey);
     return lruListFor(ex->m_accessCount, x->size()) == lruListFor(ey->m_accessCount, y->size());
 }
 
 } // namespace blink