Refine memory accounting in ImageDecodingStore for discardable entries.

Source/platform/graphics/ImageDecodingStore.h

 /*
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 143 matching lines @@
     public:
         enum CacheType {
             TypeImage,
             TypeDecoder,
         };
 
         CacheEntry(const ImageFrameGenerator* generator, int useCount, bool isDiscardable)
             : m_generator(generator)
             , m_useCount(useCount)
             , m_isDiscardable(isDiscardable)
+            , m_isAccountingEnabled(true)
             , m_prev(0)
             , m_next(0)
         {
         }
 
         virtual ~CacheEntry()
         {
             ASSERT(!m_useCount);
         }
 
         const ImageFrameGenerator* generator() const { return m_generator; }
         int useCount() const { return m_useCount; }
         void incrementUseCount() { ++m_useCount; }
         void decrementUseCount() { --m_useCount; ASSERT(m_useCount >= 0); }
         bool isDiscardable() const { return m_isDiscardable; }
 
+        void disableAccounting() { m_isAccountingEnabled = false; }
+        bool isAccountingEnabled() const { return m_isAccountingEnabled; }
+
         // FIXME: getSafeSize() returns size in bytes truncated to a 32-bits integer.
         //        Find a way to get the size in 64-bits.
         virtual size_t memoryUsageInBytes() const = 0;
         virtual CacheType type() const = 0;
 
     protected:
         const ImageFrameGenerator* m_generator;
         int m_useCount;
         bool m_isDiscardable;
+        bool m_isAccountingEnabled;
 
     private:
         CacheEntry* m_prev;
         CacheEntry* m_next;
     };
 
     class ImageCacheEntry : public CacheEntry {
     public:
         static PassOwnPtr<ImageCacheEntry> createAndUse(const ImageFrameGenerator* generator, PassOwnPtr<ScaledImageFragment> image)
         {
@@ skipping 110 matching lines @@
     typedef HashSet<ImageCacheKey> ImageCacheKeySet;
     typedef HashMap<const ImageFrameGenerator*, ImageCacheKeySet> ImageCacheKeyMap;
     ImageCacheKeyMap m_imageCacheKeyMap;
 
     // A lookup table to map ImageFrameGenerator to all associated
     // decoder cache keys.
     typedef HashSet<DecoderCacheKey> DecoderCacheKeySet;
     typedef HashMap<const ImageFrameGenerator*, DecoderCacheKeySet> DecoderCacheKeyMap;
     DecoderCacheKeyMap m_decoderCacheKeyMap;
 
+    size_t m_discardableEntriesCount;
     size_t m_cacheLimitInBytes;
     size_t m_memoryUsageInBytes;
 
     // Protect concurrent access to these members:
     //   m_orderedCacheList
     //   m_imageCacheMap, m_decoderCacheMap and all CacheEntrys stored in it
     //   m_imageCacheKeyMap
     //   m_decoderCacheKeyMap
     //   m_cacheLimitInBytes
     //   m_memoryUsageInBytes
     // This mutex also protects calls to underlying skBitmap's
     // lockPixels()/unlockPixels() as they are not threadsafe.
     Mutex m_mutex;
 };
 
 } // namespace WebCore
 
 #endif