Allow eviction of ImageBitmaps that are created from ImageElements.

Source/core/loader/cache/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 34 matching lines @@
 #include "wtf/TemporaryChange.h"
 #include "wtf/text/CString.h"
 
 using namespace std;
 
 namespace WebCore {
 
 static MemoryCache* gMemoryCache;
 
 static const int cDefaultCacheCapacity = 8192 * 1024;
-static const double cMinDelayBeforeLiveDecodedPrune = 1; // Seconds.

[Justin Novosad, 2013/07/23 16:55:12]

This variable should still exist, but it should be called
cDefaultDelayBeforeLiveDecodedPrune.  Use this constant in the constructor below
instead of the hard coded 1.

 static const float cTargetPrunePercentage = .95f; // Percentage of capacity toward which we prune, to avoid immediately pruning again.
 static const double cDefaultDecodedDataDeletionInterval = 0;
 
 MemoryCache* memoryCache()
 {
     ASSERT(WTF::isMainThread());
     if (!gMemoryCache)
         gMemoryCache = new MemoryCache();
     return gMemoryCache;
 }
 
 void setMemoryCacheForTesting(MemoryCache* memoryCache)
 {
     gMemoryCache = memoryCache;
 }
 
 MemoryCache::MemoryCache()
     : m_inPruneResources(false)
     , m_capacity(cDefaultCacheCapacity)
     , m_minDeadCapacity(0)
     , m_maxDeadCapacity(cDefaultCacheCapacity)
     , m_deadDecodedDataDeletionInterval(cDefaultDecodedDataDeletionInterval)
     , m_liveSize(0)
     , m_deadSize(0)
+    , m_delayBeforeLiveDecodedPrune(1) // Seconds.
 #ifdef MEMORY_CACHE_STATS
     , m_statsTimer(this, &MemoryCache::dumpStats)
 #endif
 {
 #ifdef MEMORY_CACHE_STATS
     const double statsIntervalInSeconds = 15;
     m_statsTimer.startRepeating(statsIntervalInSeconds);
 #endif
 }
 
@@ skipping 89 matching lines @@
 {
     if (m_inPruneResources)
         return;
     TemporaryChange<bool> reentrancyProtector(m_inPruneResources, true);
 
     double currentTime = FrameView::currentPaintTimeStamp();
     if (!currentTime) // In case prune is called directly, outside of a Frame paint.
         currentTime = WTF::currentTime();
     
     // Destroy any decoded data in live objects that we can.
-    // Start from the tail, since this is the least recently accessed of the objects.
+    // Start from the tail, since this is the lowest priority
+    // and least recently accessed of the objects.
 
     // The list might not be sorted by the m_lastDecodedAccessTime. The impact
     // of this weaker invariant is minor as the below if statement to check the
     // elapsedTime will evaluate to false as the currentTime will be a lot
     // greater than the current->m_lastDecodedAccessTime.
     // For more details see: https://bugs.webkit.org/show_bug.cgi?id=30209
-    CachedResource* current = m_liveDecodedResources.m_tail;
-    while (current) {
-        CachedResource* prev = current->m_prevInLiveResourcesList;
-        ASSERT(current->hasClients());
-        if (current->isLoaded() && current->decodedSize()) {
-            // Check to see if the remaining resources are too new to prune.
-            double elapsedTime = currentTime - current->m_lastDecodedAccessTime;
-            if (elapsedTime < cMinDelayBeforeLiveDecodedPrune)
-                return;
 
-            // Destroy our decoded data. This will remove us from 
-            // m_liveDecodedResources, and possibly move us to a different LRU 
-            // list in m_allResources.
-            current->destroyDecodedData();
+    // Start pruning from the lowest priority list.
+    for (int i = 0; i < 3; i++) {
+        CachedResource* current = m_liveDecodedResources[i].m_tail;
+        while (current) {
+            CachedResource* prev = current->m_prevInLiveResourcesList;
+            ASSERT(current->hasClients());
+            if (current->isLoaded() && current->decodedSize()) {
+                // Check to see if the remaining resources are too new to prune.
+                double elapsedTime = currentTime - current->m_lastDecodedAccessTime;
+                if (elapsedTime < m_delayBeforeLiveDecodedPrune)
+                    return;
 
-            if (targetSize && m_liveSize <= targetSize)
-                return;
+                // Destroy our decoded data. This will remove us from
+                // m_liveDecodedResources, and possibly move us to a different LRU
+                // list in m_allResources.
+                current->destroyDecodedData();
+
+                if (targetSize && m_liveSize <= targetSize)
+                    return;
+            }
+            current = prev;
         }
-        current = prev;
     }
 }
 
 void MemoryCache::pruneDeadResources()
 {
     unsigned capacity = deadCapacity();
     if (capacity && m_deadSize <= capacity)
         return;
 
     unsigned targetSize = static_cast<unsigned>(capacity * cTargetPrunePercentage); // Cut by a percentage to avoid immediately pruning again.
@@ skipping 207 matching lines @@
 
 }
 
 void MemoryCache::removeFromLiveDecodedResourcesList(CachedResource* resource)
 {
     // If we've never been accessed, then we're brand new and not in any list.
     if (!resource->m_inLiveDecodedResourcesList)
         return;
     resource->m_inLiveDecodedResourcesList = false;
 
+    LRUList* list = &m_liveDecodedResources[resource->decodePriority()];
+
 #if !ASSERT_DISABLED
     // Verify that we are in fact in this list.
     bool found = false;
-    for (CachedResource* current = m_liveDecodedResources.m_head; current; current = current->m_nextInLiveResourcesList) {
+    for (CachedResource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
         if (current == resource) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
 
     CachedResource* next = resource->m_nextInLiveResourcesList;
     CachedResource* prev = resource->m_prevInLiveResourcesList;
-    
-    if (next == 0 && prev == 0 && m_liveDecodedResources.m_head != resource)
+
+    if (!next && !prev && list->m_head != resource)
         return;
-    
+
     resource->m_nextInLiveResourcesList = 0;
     resource->m_prevInLiveResourcesList = 0;
     
     if (next)
         next->m_prevInLiveResourcesList = prev;
-    else if (m_liveDecodedResources.m_tail == resource)
-        m_liveDecodedResources.m_tail = prev;
+    else if (list->m_tail == resource)
+        list->m_tail = prev;
 
     if (prev)
         prev->m_nextInLiveResourcesList = next;
-    else if (m_liveDecodedResources.m_head == resource)
-        m_liveDecodedResources.m_head = next;
+    else if (list->m_head == resource)
+        list->m_head = next;
 }
 
 void MemoryCache::insertInLiveDecodedResourcesList(CachedResource* resource)
 {
     // Make sure we aren't in the list already.
     ASSERT(!resource->m_nextInLiveResourcesList && !resource->m_prevInLiveResourcesList && !resource->m_inLiveDecodedResourcesList);
     resource->m_inLiveDecodedResourcesList = true;
 
-    resource->m_nextInLiveResourcesList = m_liveDecodedResources.m_head;
-    if (m_liveDecodedResources.m_head)
-        m_liveDecodedResources.m_head->m_prevInLiveResourcesList = resource;
-    m_liveDecodedResources.m_head = resource;
-    
+    LRUList* list = &m_liveDecodedResources[resource->decodePriority()];
+    resource->m_nextInLiveResourcesList = list->m_head;
+    if (list->m_head)
+        list->m_head->m_prevInLiveResourcesList = resource;
+    list->m_head = resource;
+
     if (!resource->m_nextInLiveResourcesList)
-        m_liveDecodedResources.m_tail = resource;
-        
+        list->m_tail = resource;
+
 #if !ASSERT_DISABLED
     // Verify that we are in now in the list like we should be.
     bool found = false;
-    for (CachedResource* current = m_liveDecodedResources.m_head; current; current = current->m_nextInLiveResourcesList) {
+    for (CachedResource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
         if (current == resource) {
             found = true;
             break;
         }
     }
     ASSERT(found);
 #endif
 
 }
 
@@ skipping 80 matching lines @@
     }
     return stats;
 }
 
 void MemoryCache::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::MemoryCacheStructures);
     memoryObjectInfo->setClassName("MemoryCache");
     info.addMember(m_resources, "resources");
     info.addMember(m_allResources, "allResources");
-    info.addMember(m_liveDecodedResources, "liveDecodedResources");
+    for (int i = 0; i < 3; ++i)
+        info.addMember(m_liveDecodedResources[i], "liveDecodedResources");
     for (CachedResourceMap::const_iterator i = m_resources.begin(); i != m_resources.end(); ++i)
         info.addMember(i->value, "cachedResourceItem", WTF::RetainingPointer);
 }
 
 void MemoryCache::evictResources()
 {
     for (;;) {
         CachedResourceMap::iterator i = m_resources.begin();
         if (i == m_resources.end())
             break;
@@ skipping 55 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