Reland "Move MemoryCache implementation details out of Resource"

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 91 matching lines @@
     if (!originalURL.protocolIsInHTTPFamily())
         return originalURL;
     KURL url = originalURL;
     url.removeFragmentIdentifier();
     return url;
 }
 
 void MemoryCache::add(Resource* resource)
 {
     ASSERT(WTF::isMainThread());
-    m_resources.set(resource->url(), resource);
+    ASSERT(!m_resources.contains(resource->url()));
+    m_resources.set(resource->url(), MemoryCacheEntry::create(resource));
     resource->setInCache(true);
     resource->updateForAccess();
 
     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.get(newResource->url()));
-    m_resources.set(newResource->url(), newResource);
+    ASSERT(!m_resources.contains(newResource->url()));
+    m_resources.set(newResource->url(), MemoryCacheEntry::create(newResource));
     newResource->setInCache(true);
     insertInLRUList(newResource);
     int delta = newResource->size();
     if (newResource->decodedSize() && newResource->hasClients())
         insertInLiveDecodedResourcesList(newResource);
     if (delta)
         adjustSize(newResource->hasClients(), delta);
 }
 
 Resource* MemoryCache::resourceForURL(const KURL& resourceURL)
 {
     ASSERT(WTF::isMainThread());
     KURL url = removeFragmentIdentifierIfNeeded(resourceURL);
-    Resource* resource = m_resources.get(url);
+    MemoryCacheEntry* entry = m_resources.get(url);
+    if (!entry)
+        return 0;
+    Resource* resource = entry->m_resource.get();
     if (resource && !resource->lock()) {
         ASSERT(!resource->hasClients());
         bool didEvict = evict(resource);
         ASSERT_UNUSED(didEvict, didEvict);
         return 0;
     }
     return resource;
 }
 
 size_t MemoryCache::deadCapacity() const
@@ skipping 25 matching lines @@
     // and least recently accessed of the objects.
 
     // The list might not be sorted by the m_lastDecodedFrameTimeStamp. The impact
     // of this weaker invariant is minor as the below if statement to check the
     // elapsedTime will evaluate to false as the current time will be a lot
     // greater than the current->m_lastDecodedFrameTimeStamp.
     // For more details see: https://bugs.webkit.org/show_bug.cgi?id=30209
 
     // Start pruning from the lowest priority list.
     for (int priority = Resource::CacheLiveResourcePriorityLow; priority <= Resource::CacheLiveResourcePriorityHigh; ++priority) {
-        Resource* current = m_liveDecodedResources[priority].m_tail;
+        MemoryCacheEntry* current = m_liveDecodedResources[priority].m_tail;
         while (current) {
-            Resource* prev = current->m_prevInLiveResourcesList;
-            ASSERT(current->hasClients());
-            if (current->isLoaded() && current->decodedSize()) {
+            MemoryCacheEntry* previous = current->m_previousInLiveResourcesList;
+            ASSERT(current->m_resource->hasClients());
+            if (current->m_resource->isLoaded() && current->m_resource->decodedSize()) {
                 // Check to see if the remaining resources are too new to prune.
-                double elapsedTime = m_pruneFrameTimeStamp - current->m_lastDecodedAccessTime;
+                double elapsedTime = m_pruneFrameTimeStamp - current->m_resource->m_lastDecodedAccessTime;
                 if (elapsedTime < m_delayBeforeLiveDecodedPrune)
                     return;
 
                 // Destroy our decoded data if possible. This will remove us
                 // from m_liveDecodedResources, and possibly move us to a
                 // different LRU list in m_allResources.
-                current->prune();
+                current->m_resource->prune();
 
                 if (targetSize && m_liveSize <= targetSize)
                     return;
             }
-            current = prev;
+            current = previous;
         }
     }
 }
 
 void MemoryCache::pruneDeadResources()
 {
     size_t capacity = deadCapacity();
     if (!m_deadSize || (capacity && m_deadSize <= capacity))
         return;
 
     size_t targetSize = static_cast<size_t>(capacity * cTargetPrunePercentage); // Cut by a percentage to avoid immediately pruning again.
 
     int size = m_allResources.size();
 
     // See if we have any purged resources we can evict.
     for (int i = 0; i < size; i++) {
-        Resource* current = m_allResources[i].m_tail;
+        MemoryCacheEntry* current = m_allResources[i].m_tail;
         while (current) {
-            Resource* prev = current->m_prevInAllResourcesList;
-            if (current->wasPurged()) {
-                ASSERT(!current->hasClients());
-                ASSERT(!current->isPreloaded());
-                evict(current);
+            MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
+            if (current->m_resource->wasPurged()) {
+                ASSERT(!current->m_resource->hasClients());
+                ASSERT(!current->m_resource->isPreloaded());
+                evict(current->m_resource.get());
             }
-            current = prev;
+            current = previous;
         }
     }
     if (targetSize && m_deadSize <= targetSize)
         return;
 
     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.
-        Resource* current = m_allResources[i].m_tail;
+        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().
-            ResourcePtr<Resource> previous = current->m_prevInAllResourcesList;
-            ASSERT(!previous || previous->inCache());
-            if (!current->hasClients() && !current->isPreloaded() && current->isLoaded()) {
-                // Destroy our decoded data if possible. This will remove us
-                // from m_liveDecodedResources, and possibly move us to a
-                // different LRU list in m_allResources.
-                current->prune();
+            MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
+            ASSERT(!previous || previous->m_resource->inCache());
+            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->inCache())
+            if (previous && !previous->m_resource->inCache())
                 break;
-            current = previous.get();
+            current = previous;
         }
 
         // Now evict objects from this queue.
         current = m_allResources[i].m_tail;
         while (current) {
-            ResourcePtr<Resource> previous = current->m_prevInAllResourcesList;
-            ASSERT(!previous || previous->inCache());
-            if (!current->hasClients() && !current->isPreloaded() && !current->isCacheValidator()) {
-                evict(current);
+            MemoryCacheEntry* previous = current->m_previousInAllResourcesList;
+            ASSERT(!previous || previous->m_resource->inCache());
+            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->inCache())
+            if (previous && !previous->m_resource->inCache())
                 break;
-            current = previous.get();
+            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);
     }
 }
 
 void MemoryCache::setCapacities(size_t minDeadBytes, size_t maxDeadBytes, size_t totalBytes)
 {
     ASSERT(minDeadBytes <= maxDeadBytes);
     ASSERT(maxDeadBytes <= totalBytes);
     m_minDeadCapacity = minDeadBytes;
     m_maxDeadCapacity = maxDeadBytes;
     m_maxDeferredPruneDeadCapacity = cDeferredPruneDeadCapacityFactor * maxDeadBytes;
     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 resource map.
-        m_resources.remove(resource->url());
-        resource->setInCache(false);
-
         // Remove from the appropriate LRU list.
         removeFromLRUList(resource);
         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()) != resource);
+        ASSERT(!m_resources.get(resource->url()) || m_resources.get(resource->url())->m_resource != resource);
     }
 
     return resource->deleteIfPossible();
 }
 
-MemoryCache::LRUList* MemoryCache::lruListFor(Resource* resource)
+MemoryCache::LRUList* MemoryCache::lruListFor(MemoryCacheEntry* entry)
 {
-    unsigned accessCount = std::max(resource->accessCount(), 1U);
-    unsigned queueIndex = WTF::fastLog2(resource->size() / accessCount);
-#ifndef NDEBUG
-    resource->m_lruIndex = queueIndex;
-#endif
+    unsigned accessCount = std::max(entry->m_resource->accessCount(), 1U);
+    unsigned queueIndex = WTF::fastLog2(entry->m_resource->size() / accessCount);
     if (m_allResources.size() <= queueIndex)
         m_allResources.grow(queueIndex + 1);
     return &m_allResources[queueIndex];
 }
 
 void MemoryCache::removeFromLRUList(Resource* resource)
 {
     // If we've never been accessed, then we're brand new and not in any list.
     if (!resource->accessCount())
         return;
 
-#if !ASSERT_DISABLED
-    unsigned oldListIndex = resource->m_lruIndex;
-#endif
-
-    LRUList* list = lruListFor(resource);
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+    ASSERT(entry->m_resource == resource);
+    LRUList* list = lruListFor(entry);
 
 #if !ASSERT_DISABLED
-    // Verify that the list we got is the list we want.
-    ASSERT(resource->m_lruIndex == oldListIndex);
-
     // Verify that we are in fact in this list.
     bool found = false;
-    for (Resource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
-        if (current == resource) {
+    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
+        if (current == entry) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
 
-    Resource* next = resource->m_nextInAllResourcesList;
-    Resource* prev = resource->m_prevInAllResourcesList;
+    MemoryCacheEntry* next = entry->m_nextInAllResourcesList;
+    MemoryCacheEntry* previous = entry->m_previousInAllResourcesList;
 
-    if (!next && !prev && list->m_head != resource)
-        return;
-
-    resource->m_nextInAllResourcesList = 0;
-    resource->m_prevInAllResourcesList = 0;
+    entry->m_nextInAllResourcesList = 0;
+    entry->m_previousInAllResourcesList = 0;
 
     if (next)
-        next->m_prevInAllResourcesList = prev;
-    else if (list->m_tail == resource)
-        list->m_tail = prev;
+        next->m_previousInAllResourcesList = previous;
+    else
+        list->m_tail = previous;
 
-    if (prev)
-        prev->m_nextInAllResourcesList = next;
-    else if (list->m_head == resource)
+    if (previous)
+        previous->m_nextInAllResourcesList = next;
+    else
         list->m_head = next;
 }
 
 void MemoryCache::insertInLRUList(Resource* resource)
 {
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+    ASSERT(entry->m_resource == resource);
+
     // Make sure we aren't in some list already.
-    ASSERT(!resource->m_nextInAllResourcesList && !resource->m_prevInAllResourcesList);
+    ASSERT(!entry->m_nextInAllResourcesList && !entry->m_previousInAllResourcesList);
     ASSERT(resource->inCache());
     ASSERT(resource->accessCount() > 0);
 
-    LRUList* list = lruListFor(resource);
+    LRUList* list = lruListFor(entry);
 
-    resource->m_nextInAllResourcesList = list->m_head;
+    entry->m_nextInAllResourcesList = list->m_head;
     if (list->m_head)
-        list->m_head->m_prevInAllResourcesList = resource;
-    list->m_head = resource;
+        list->m_head->m_previousInAllResourcesList = entry;
+    list->m_head = entry;
 
-    if (!resource->m_nextInAllResourcesList)
-        list->m_tail = resource;
+    if (!entry->m_nextInAllResourcesList)
+        list->m_tail = entry;
 
 #if !ASSERT_DISABLED
     // Verify that we are in now in the list like we should be.
-    list = lruListFor(resource);
+    list = lruListFor(entry);
     bool found = false;
-    for (Resource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
-        if (current == resource) {
+    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
+        if (current == entry) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
-
 }
 
 void MemoryCache::removeFromLiveDecodedResourcesList(Resource* resource)
 {
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+    ASSERT(entry->m_resource == resource);
+
     // If we've never been accessed, then we're brand new and not in any list.
-    if (!resource->m_inLiveDecodedResourcesList)
+    if (!entry->m_inLiveDecodedResourcesList)
         return;
-    resource->m_inLiveDecodedResourcesList = false;
+    entry->m_inLiveDecodedResourcesList = false;
 
     LRUList* list = &m_liveDecodedResources[resource->cacheLiveResourcePriority()];
 
 #if !ASSERT_DISABLED
     // Verify that we are in fact in this list.
     bool found = false;
-    for (Resource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
-        if (current == resource) {
+    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
+        if (current == entry) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
 
-    Resource* next = resource->m_nextInLiveResourcesList;
-    Resource* prev = resource->m_prevInLiveResourcesList;
+    MemoryCacheEntry* next = entry->m_nextInLiveResourcesList;
+    MemoryCacheEntry* previous = entry->m_previousInLiveResourcesList;
 
-    if (!next && !prev && list->m_head != resource)
-        return;
-
-    resource->m_nextInLiveResourcesList = 0;
-    resource->m_prevInLiveResourcesList = 0;
+    entry->m_nextInLiveResourcesList = 0;
+    entry->m_previousInLiveResourcesList = 0;
 
     if (next)
-        next->m_prevInLiveResourcesList = prev;
-    else if (list->m_tail == resource)
-        list->m_tail = prev;
+        next->m_previousInLiveResourcesList = previous;
+    else
+        list->m_tail = previous;
 
-    if (prev)
-        prev->m_nextInLiveResourcesList = next;
-    else if (list->m_head == resource)
+    if (previous)
+        previous->m_nextInLiveResourcesList = next;
+    else
         list->m_head = next;
 }
 
 void MemoryCache::insertInLiveDecodedResourcesList(Resource* resource)
 {
+    MemoryCacheEntry* entry = m_resources.get(resource->url());
+    ASSERT(entry->m_resource == resource);
+
     // Make sure we aren't in the list already.
-    ASSERT(!resource->m_nextInLiveResourcesList && !resource->m_prevInLiveResourcesList && !resource->m_inLiveDecodedResourcesList);
-    resource->m_inLiveDecodedResourcesList = true;
+    ASSERT(!entry->m_nextInLiveResourcesList && !entry->m_previousInLiveResourcesList && !entry->m_inLiveDecodedResourcesList);
+    entry->m_inLiveDecodedResourcesList = true;
 
     LRUList* list = &m_liveDecodedResources[resource->cacheLiveResourcePriority()];
-    resource->m_nextInLiveResourcesList = list->m_head;
+    entry->m_nextInLiveResourcesList = list->m_head;
     if (list->m_head)
-        list->m_head->m_prevInLiveResourcesList = resource;
-    list->m_head = resource;
+        list->m_head->m_previousInLiveResourcesList = entry;
+    list->m_head = entry;
 
-    if (!resource->m_nextInLiveResourcesList)
-        list->m_tail = resource;
+    if (!entry->m_nextInLiveResourcesList)
+        list->m_tail = entry;
 
 #if !ASSERT_DISABLED
     // Verify that we are in now in the list like we should be.
     bool found = false;
-    for (Resource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
-        if (current == resource) {
+    for (MemoryCacheEntry* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
+        if (current == entry) {
             found = true;
             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;
 }
 
 void MemoryCache::addToLiveResourcesSize(Resource* resource)
 {
     ASSERT(m_deadSize >= resource->size());
     m_liveSize += resource->size();
     m_deadSize -= resource->size();
 }
 
 void MemoryCache::removeFromLiveResourcesSize(Resource* resource)
@@ skipping 43 matching lines @@
     encodedSizeDuplicatedInDataURLs += o->url().protocolIsData() ? o->encodedSize() : 0;
     purgeableSize += purgeable ? pageSize : 0;
     purgedSize += purged ? pageSize : 0;
 }
 
 MemoryCache::Statistics MemoryCache::getStatistics()
 {
     Statistics stats;
     ResourceMap::iterator e = m_resources.end();
     for (ResourceMap::iterator i = m_resources.begin(); i != e; ++i) {
-        Resource* resource = i->value;
+        Resource* resource = i->value->m_resource.get();
         switch (resource->type()) {
         case Resource::Image:
             stats.images.addResource(resource);
             break;
         case Resource::CSSStyleSheet:
             stats.cssStyleSheets.addResource(resource);
             break;
         case Resource::Script:
             stats.scripts.addResource(resource);
             break;
@@ skipping 10 matching lines @@
     }
     return stats;
 }
 
 void MemoryCache::evictResources()
 {
     for (;;) {
         ResourceMap::iterator i = m_resources.begin();
         if (i == m_resources.end())
             break;
-        evict(i->value);
+        evict(i->value->m_resource.get());
     }
 }
 
 void MemoryCache::prune(Resource* justReleasedResource)
 {
     TRACE_EVENT0("renderer", "MemoryCache::prune()");
 
     if (m_inPruneResources)
         return;
     if (m_liveSize + m_deadSize <= m_capacity && m_maxDeadCapacity && m_deadSize <= m_maxDeadCapacity) // Fast path.
@@ skipping 99 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