MemoryCache: Remove ENABLE(ASSERT) checks for readability

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 386 matching lines @@
 {
     ASSERT(accessCount > 0);
     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)
 {
-#if ENABLE(ASSERT)
-    // Verify that we are in fact in this list.
-    bool found = false;
-    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
-        if (current == entry) {
-            found = true;
-            break;
-        }
-    }
-    ASSERT(found);
-#endif
+    ASSERT(containsInLRUList(entry, list));

[Mike West, 2014/10/16 06:34:46]

This is a huge improvement, thank you.

 
     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(!containsInLRUList(entry, list));
 }
 
 void MemoryCache::insertInLRUList(MemoryCacheEntry* entry, MemoryCacheLRUList* list)
 {
-    ASSERT(!entry->m_nextInAllResourcesList && !entry->m_previousInAllResourcesList);
+    ASSERT(!containsInLRUList(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;
 
-#if ENABLE(ASSERT)
-    // Verify that we are in now in the list like we should be.
-    bool found = false;
+    ASSERT(containsInLRUList(entry, list));
+}
+
+bool MemoryCache::containsInLRUList(MemoryCacheEntry* entry, MemoryCacheLRUList* list)
+{
     for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
-        if (current == entry) {
-            found = true;
-            break;
-        }
+        if (current == entry)
+            return true;
     }
-    ASSERT(found);
-#endif
+    ASSERT(!entry->m_nextInAllResourcesList && !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(containsInLiveDecodedResourcesList(entry));
+
     entry->m_inLiveDecodedResourcesList = false;
 
     MemoryCacheLRUList* list = &m_liveDecodedResources[entry->m_liveResourcePriority];
 
-#if ENABLE(ASSERT)
-    // Verify that we are in fact in this list.
-    bool found = false;
-    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
-        if (current == entry) {
-            found = true;
-            break;
-        }
-    }
-    ASSERT(found);
-#endif
-
     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
         list->m_tail = previous;
 
     if (previous)
         previous->m_nextInLiveResourcesList = next;
     else
         list->m_head = next;
+
+    ASSERT(!containsInLiveDecodedResourcesList(entry));
 }
 
 void MemoryCache::insertInLiveDecodedResourcesList(MemoryCacheEntry* entry)
 {
-    // Make sure we aren't in the list already.
-    ASSERT(!entry->m_nextInLiveResourcesList && !entry->m_previousInLiveResourcesList && !entry->m_inLiveDecodedResourcesList);
+    ASSERT(!containsInLiveDecodedResourcesList(entry));
+
     entry->m_inLiveDecodedResourcesList = true;
 
     MemoryCacheLRUList* list = &m_liveDecodedResources[entry->m_liveResourcePriority];
     entry->m_nextInLiveResourcesList = list->m_head;
     if (list->m_head)
         list->m_head->m_previousInLiveResourcesList = entry;
     list->m_head = entry;
 
     if (!entry->m_nextInLiveResourcesList)
         list->m_tail = entry;
 
-#if ENABLE(ASSERT)
-    // Verify that we are in now in the list like we should be.
-    bool found = false;
+    ASSERT(containsInLiveDecodedResourcesList(entry));
+}
+
+bool MemoryCache::containsInLiveDecodedResourcesList(MemoryCacheEntry* entry)
+{
+    MemoryCacheLRUList* list = &m_liveDecodedResources[entry->m_liveResourcePriority];
     for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
         if (current == entry) {
-            found = true;
-            break;
+            ASSERT(entry->m_inLiveDecodedResourcesList);
+            return true;
         }
     }
-    ASSERT(found);
-#endif
+    ASSERT(!entry->m_nextInLiveResourcesList && !entry->m_previousInLiveResourcesList && !entry->m_inLiveDecodedResourcesList);
+    return false;
 }
 
 void MemoryCache::makeLive(Resource* resource)
 {
     if (!contains(resource))
         return;
     ASSERT(m_deadSize >= resource->size());
     m_liveSize += resource->size();
     m_deadSize -= resource->size();
 }
@@ skipping 268 matching lines @@
                 printf("(%.1fK, %.1fK, %uA, %dR, %d, %d); ", current->decodedSize() / 1024.0f, (current->encodedSize() + current->overheadSize()) / 1024.0f, current->accessCount(), current->hasClients(), current->isPurgeable(), current->wasPurged());
 
             current = prev;
         }
     }
 }
 
 #endif // MEMORY_CACHE_STATS
 
 } // namespace blink