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.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "config.h"
 #include "core/loader/cache/MemoryCache.h"
 
 #include <stdio.h>
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
-#include "core/loader/cache/CachedResource.h"
 #include "core/loader/cache/CachedResourceHandle.h"
 #include "core/page/FrameView.h"
 #include "core/platform/Logging.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "weborigin/SecurityOrigin.h"
 #include "weborigin/SecurityOriginHash.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
@@ skipping 24 matching lines @@
     gMemoryCache = memoryCache;
 }
 
 MemoryCache::MemoryCache()
     : m_inPruneResources(false)
     , m_capacity(cDefaultCacheCapacity)
     , m_minDeadCapacity(0)
     , m_maxDeadCapacity(cDefaultCacheCapacity)
     , m_liveSize(0)
     , m_deadSize(0)
+    , m_delayBeforeLiveDecodedPrune(cMinDelayBeforeLiveDecodedPrune)
 #ifdef MEMORY_CACHE_STATS
     , m_statsTimer(this, &MemoryCache::dumpStats)
 #endif
 {
 #ifdef MEMORY_CACHE_STATS
     const double statsIntervalInSeconds = 15;
     m_statsTimer.startRepeating(statsIntervalInSeconds);
 #endif
 }
 
@@ skipping 69 matching lines @@
     if (capacity && m_liveSize <= capacity)
         return;
 
     unsigned targetSize = static_cast<unsigned>(capacity * cTargetPrunePercentage); // Cut by a percentage to avoid immediately pruning again.
 
     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 priority = CachedResource::CacheLiveResourcePriorityLow; priority <= CachedResource::CacheLiveResourcePriorityHigh; ++priority) {
+        CachedResource* current = m_liveDecodedResources[priority].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 188 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->cacheLiveResourcePriority()];
+
 #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->cacheLiveResourcePriority()];
+    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 142 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