Make MemoryCache's LRUList manipulation private

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 93 matching lines @@
     KURL url = originalURL;
     url.removeFragmentIdentifier();
     return url;
 }
 
 void MemoryCache::add(Resource* resource)
 {
     ASSERT(WTF::isMainThread());
     ASSERT(!m_resources.contains(resource->url()));
     m_resources.set(resource->url(), MemoryCacheEntry::create(resource));
-    resource->setInCache(true);
-    resource->updateForAccess();
+    update(resource, 0, resource->size(), true);
 
     WTF_LOG(ResourceLoading, "MemoryCache::add Added '%s', resource %p\n", resource->url().string().latin1().data(), resource);
 }
 
 void MemoryCache::replace(Resource* newResource, Resource* oldResource)
 {
     evict(oldResource);
-    ASSERT(!m_resources.contains(newResource->url()));
-    m_resources.set(newResource->url(), MemoryCacheEntry::create(newResource));
-    newResource->setInCache(true);
-    insertInLRUList(newResource);
-    int delta = newResource->size();
+    add(newResource);
     if (newResource->decodedSize() && newResource->hasClients())
         insertInLiveDecodedResourcesList(newResource);
-    if (delta)
-        adjustSize(newResource->hasClients(), delta);
+}
+
+bool MemoryCache::contains(Resource* resource)
+{
+    if (resource->url().isNull())
+        return false;
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+    return entry && entry->m_resource == resource;
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL)
 {
     ASSERT(WTF::isMainThread());
     KURL url = removeFragmentIdentifierIfNeeded(resourceURL);
     MemoryCacheEntry* entry = m_resources.get(url);
     if (!entry)
         return 0;
     Resource* resource = entry->m_resource.get();
@@ skipping 93 matching lines @@
 
     bool canShrinkLRULists = true;
     for (int i = size - 1; i >= 0; i--) {
         // Remove from the tail, since this is the least frequently accessed of the objects.
         MemoryCacheEntry* current = m_allResources[i].m_tail;
 
         // First flush all the decoded data in this queue.
         while (current) {
             // Protect 'previous' so it can't get deleted during destroyDecodedData().
             MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
-            ASSERT(!previous || previous->m_resource->inCache());
+            ASSERT(!previous || contains(previous->m_resource.get()));
             if (!current->m_resource->hasClients() && !current->m_resource->isPreloaded() && current->m_resource->isLoaded()) {
                 // Destroy our decoded data. This will remove us from
                 // m_liveDecodedResources, and possibly move us to a different
                 // LRU list in m_allResources.
                 current->m_resource->prune();
 
                 if (targetSize && m_deadSize <= targetSize)
                     return;
             }
             // Decoded data may reference other resources. Stop iterating if 'previous' somehow got
             // kicked out of cache during destroyDecodedData().
-            if (previous && !previous->m_resource->inCache())
+            if (previous && !contains(previous->m_resource.get()))
                 break;
             current = previous;
         }
 
         // Now evict objects from this queue.
         current = m_allResources[i].m_tail;
         while (current) {
             MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
-            ASSERT(!previous || previous->m_resource->inCache());
+            ASSERT(!previous || contains(previous->m_resource.get()));
             if (!current->m_resource->hasClients() && !current->m_resource->isPreloaded() && !current->m_resource->isCacheValidator()) {
                 evict(current->m_resource.get());
                 if (targetSize && m_deadSize <= targetSize)
                     return;
             }
-            if (previous && !previous->m_resource->inCache())
+            if (previous && !contains(previous->m_resource.get()))
                 break;
             current = previous;
         }
 
         // Shrink the vector back down so we don't waste time inspecting
         // empty LRU lists on future prunes.
         if (m_allResources[i].m_head)
             canShrinkLRULists = false;
         else if (canShrinkLRULists)
             m_allResources.resize(i);
@@ skipping 10 matching lines @@
     m_capacity = totalBytes;
     prune();
 }
 
 bool MemoryCache::evict(Resource* resource)
 {
     ASSERT(WTF::isMainThread());
     WTF_LOG(ResourceLoading, "Evicting resource %p for '%s' from cache", resource, resource->url().string().latin1().data());
     // 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>.
-    if (resource->inCache()) {
-        // Remove from the appropriate LRU list.
-        removeFromLRUList(resource);
+    if (contains(resource)) {
+        update(resource, resource->size(), 0, false);
         removeFromLiveDecodedResourcesList(resource);
-        adjustSize(resource->hasClients(), -static_cast<ptrdiff_t>(resource->size()));
 
         // Remove from the resource map.
         m_resources.remove(resource->url());
-        resource->setInCache(false);
-    } else {
-        ASSERT(!m_resources.get(resource->url()) || m_resources.get(resource->url())->m_resource != resource);
     }
 
     return resource->deleteIfPossible();
 }
 
-MemoryCache::LRUList* MemoryCache::lruListFor(MemoryCacheEntry* entry)
+MemoryCache::LRUList* MemoryCache::lruListFor(unsigned accessCount, size_t size)
 {
-    unsigned accessCount = std::max(entry->m_resource->accessCount(), 1U);
-    unsigned queueIndex = WTF::fastLog2(entry->m_resource->size() / accessCount);
+    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(Resource* resource)
+void MemoryCache::removeFromLRUList(MemoryCacheEntry* entry, LRUList* list)
 {
-    MemoryCacheEntry* entry = m_resources.get(resource->url());
-    ASSERT(entry->m_resource == resource);
-
-    LRUList* list = lruListFor(entry);
-    MemoryCacheEntry* next = entry->m_nextInAllResourcesList;
-    MemoryCacheEntry* previous = entry->m_previousInAllResourcesList;
-    if (!next && !previous && list->m_head != entry)
-        return;
-
 #if !ASSERT_DISABLED
     // 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
 
+    MemoryCacheEntry* next = entry->m_nextInAllResourcesList;
+    MemoryCacheEntry* previous = entry->m_previousInAllResourcesList;
     entry->m_nextInAllResourcesList = 0;
     entry->m_previousInAllResourcesList = 0;
 
     if (next)
         next->m_previousInAllResourcesList = previous;
     else
         list->m_tail = previous;
 
     if (previous)
         previous->m_nextInAllResourcesList = next;
     else
         list->m_head = next;
 }
 
-void MemoryCache::insertInLRUList(Resource* resource)
+void MemoryCache::insertInLRUList(MemoryCacheEntry* entry, LRUList* list)
 {
-    MemoryCacheEntry* entry = m_resources.get(resource->url());
-    ASSERT(entry->m_resource == resource);
-
-    // Make sure we aren't in some list already.
     ASSERT(!entry->m_nextInAllResourcesList && !entry->m_previousInAllResourcesList);
-    ASSERT(resource->inCache());
-
-    LRUList* list = lruListFor(entry);
 
     entry->m_nextInAllResourcesList = list->m_head;
-    if (list->m_head)
-        list->m_head->m_previousInAllResourcesList = entry;
     list->m_head = entry;
 
-    if (!entry->m_nextInAllResourcesList)
+    if (entry->m_nextInAllResourcesList)
+        entry->m_nextInAllResourcesList->m_previousInAllResourcesList = entry;
+    else
         list->m_tail = entry;
 
 #if !ASSERT_DISABLED
     // Verify that we are in now in the list like we should be.
-    list = lruListFor(entry);
     bool found = false;
     for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
         if (current == entry) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
 }
@@ skipping 66 matching lines @@
             break;
         }
     }
     ASSERT(found);
 #endif
 }
 
 bool MemoryCache::isInLiveDecodedResourcesList(Resource* resource)
 {
     MemoryCacheEntry* entry = m_resources.get(resource->url());
-    ASSERT(entry->m_resource == resource);
-    return entry ? entry->m_inLiveDecodedResourcesList : false;
+    ASSERT(entry && entry->m_resource == resource);
+    return entry->m_inLiveDecodedResourcesList;
 }
 
 void MemoryCache::addToLiveResourcesSize(Resource* resource)
 {
     ASSERT(m_deadSize >= resource->size());
     m_liveSize += resource->size();
     m_deadSize -= resource->size();
 }
 
 void MemoryCache::removeFromLiveResourcesSize(Resource* resource)
 {
     ASSERT(m_liveSize >= resource->size());
     m_liveSize -= resource->size();
     m_deadSize += resource->size();
 }
 
-void MemoryCache::adjustSize(bool live, ptrdiff_t delta)
+void MemoryCache::update(Resource* resource, size_t oldSize, size_t newSize, bool wasAccessed)
 {
-    if (live) {
+    ASSERT(contains(resource));
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+
+    // The object must now be moved to a different queue, since either its size or its accessCount has been changed,
+    // 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->hasClients()) {
         ASSERT(delta >= 0 || m_liveSize >= static_cast<size_t>(-delta) );
         m_liveSize += delta;
     } else {
         ASSERT(delta >= 0 || m_deadSize >= static_cast<size_t>(-delta) );
         m_deadSize += delta;
     }
 }
 
 void MemoryCache::removeURLFromCache(ExecutionContext* context, const KURL& url)
 {
@@ skipping 175 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 WebCore