Allow eviction of ImageBitmaps that are created from ImageElements.

Source/core/loader/cache/MemoryCacheTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/loader/cache/MemoryCache.h"
 
+#include "core/loader/cache/CachedImageTest.h"
 #include "core/loader/cache/CachedRawResource.h"
 #include "core/loader/cache/CachedResourceHandle.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "wtf/OwnPtr.h"
 
 #include <gtest/gtest.h>
 
 namespace WebCore {
 
 class MemoryCacheTest : public ::testing::Test {
+public:
+    class MockCachedImage : public WebCore::CachedResource {
+    public:
+        MockCachedImage(const ResourceRequest& request, Type type, DecodeCachePriority decodeCachePriority)
+            : CachedResource(request, type, decodeCachePriority)
+        {
+        }
+
+        virtual void appendData(const char* data, int len)
+        {
+            CachedResource::appendData(data, len);
+            setDecodedSize(this->size());
+        }
+
+        virtual void destroyDecodedData()
+        {
+            setDecodedSize(0);
+            makePurgeable(true);
+        }
+    };
+
 protected:
     virtual void SetUp()
     {
         // Save the global memory cache to restore it upon teardown.
         m_globalMemoryCache = adoptPtr(memoryCache());
         // Create the test memory cache instance and hook it in.
         m_testingMemoryCache = adoptPtr(new MemoryCache());
         setMemoryCacheForTesting(m_testingMemoryCache.leakPtr());
     }
 
@@ skipping 45 matching lines @@
 
     memoryCache()->add(cachedResource.get());
     ASSERT_EQ(cachedResource->size(), memoryCache()->deadSize());
     ASSERT_EQ(0u, memoryCache()->liveSize());
 
     memoryCache()->prune();
     ASSERT_EQ(0u, memoryCache()->deadSize());
     ASSERT_EQ(0u, memoryCache()->liveSize());
 }
 
+// Verifies that CachedResources are eviced from the decode catch

[Justin Novosad, 2013/07/19 21:09:53]

catch -> cache

+// according to their DecodeCachePriority
+TEST_F(MemoryCacheTest, DecodeCacheOrder)
+{
+    CachedResourceHandle<MockCachedImage> cachedImageLowPriority =
+        new MockCachedImage(ResourceRequest(""), CachedResource::RawResource, CachedResource::DecodeCachePriorityLow);
+    CachedResourceHandle<MockCachedImage> cachedImageMediumPriority =
+        new MockCachedImage(ResourceRequest(""), CachedResource::RawResource, CachedResource::DecodeCachePriorityMedium);
+    CachedResourceHandle<MockCachedImage> cachedImageHighPriority =
+        new MockCachedImage(ResourceRequest(""), CachedResource::RawResource, CachedResource::DecodeCachePriorityHigh);
+
+    MockCachedImageClient clientLowPriority;
+    MockCachedImageClient clientMediumPriority;
+    MockCachedImageClient clientHighPriority;
+    cachedImageLowPriority->addClient(&clientLowPriority);
+    cachedImageMediumPriority->addClient(&clientMediumPriority);
+    cachedImageHighPriority->addClient(&clientHighPriority);
+
+    const char data[5] = "abcd";
+    cachedImageLowPriority->appendData(data, 1);
+    cachedImageMediumPriority->appendData(data, 2);
+    cachedImageHighPriority->appendData(data, 4);
+    const unsigned lowPrioritySize = cachedImageLowPriority->size();
+    const unsigned mediumPrioritySize = cachedImageMediumPriority->size();
+    const unsigned highPrioritySize = cachedImageHighPriority->size();
+    const unsigned lowPriorityMockDecodeSize = cachedImageLowPriority->decodedSize();
+    const unsigned mediumPriorityMockDecodeSize = cachedImageMediumPriority->decodedSize();
+    const unsigned highPriorityMockDecodeSize = cachedImageHighPriority->decodedSize();
+    const unsigned totalSize = lowPrioritySize + mediumPrioritySize + highPrioritySize;
+
+    // Verify all the sizes to be different in order to properly test eviction order
+    ASSERT_GT(lowPrioritySize, 0u);
+    ASSERT_NE(lowPrioritySize, mediumPrioritySize);
+    ASSERT_NE(mediumPrioritySize, highPrioritySize);
+    ASSERT_GT(lowPriorityMockDecodeSize, 0u);
+    ASSERT_NE(lowPriorityMockDecodeSize, mediumPriorityMockDecodeSize);
+    ASSERT_NE(mediumPriorityMockDecodeSize, highPriorityMockDecodeSize);
+
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), 0u);
+
+    // Add the three items in a random order
+    memoryCache()->add(cachedImageHighPriority.get());
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), highPrioritySize);
+
+    memoryCache()->add(cachedImageLowPriority.get());
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), highPrioritySize + lowPrioritySize);
+
+    memoryCache()->add(cachedImageMediumPriority.get());
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), highPrioritySize + mediumPrioritySize + lowPrioritySize);
+
+    memoryCache()->insertInLiveDecodedResourcesList(cachedImageHighPriority.get());
+    memoryCache()->insertInLiveDecodedResourcesList(cachedImageLowPriority.get());
+    memoryCache()->insertInLiveDecodedResourcesList(cachedImageMediumPriority.get());
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), totalSize);
+
+    // Should prune the LowPriority item
+    memoryCache()->setCapacities(memoryCache()->minDeadCapacity(), memoryCache()->maxDeadCapacity(), memoryCache()->liveSize());
+    memoryCache()->pruneToPercentage(0.90f);
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), totalSize - lowPriorityMockDecodeSize);
+
+    // Should prune the MediumPriority item
+    memoryCache()->setCapacities(memoryCache()->minDeadCapacity(), memoryCache()->maxDeadCapacity(), memoryCache()->liveSize());
+    memoryCache()->pruneToPercentage(0.90f);
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), totalSize - lowPriorityMockDecodeSize - mediumPriorityMockDecodeSize);
+
+    // Should prune the HighPriority item
+    memoryCache()->setCapacities(memoryCache()->minDeadCapacity(), memoryCache()->maxDeadCapacity(), memoryCache()->liveSize());
+    memoryCache()->pruneToPercentage(0.90f);
+    ASSERT_EQ(memoryCache()->deadSize(), 0u);
+    ASSERT_EQ(memoryCache()->liveSize(), totalSize - lowPriorityMockDecodeSize - mediumPriorityMockDecodeSize - highPriorityMockDecodeSize);
+}
 } // namespace