Make MemoryCache's LRUList manipulation private

Source/core/fetch/MemoryCache.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@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 54 matching lines @@
 public:
     MemoryCache();
     virtual ~MemoryCache();
 
     class MemoryCacheEntry {
     public:
         static PassOwnPtr<MemoryCacheEntry> create(Resource* resource) { return adoptPtr(new MemoryCacheEntry(resource)); }
 
         ResourcePtr<Resource> m_resource;
         bool m_inLiveDecodedResourcesList;
+        unsigned m_accessCount;
 
         MemoryCacheEntry* m_previousInLiveResourcesList;
         MemoryCacheEntry* m_nextInLiveResourcesList;
         MemoryCacheEntry* m_previousInAllResourcesList;
         MemoryCacheEntry* m_nextInAllResourcesList;
 
     private:
         MemoryCacheEntry(Resource* resource)
             : m_resource(resource)
             , m_inLiveDecodedResourcesList(false)
+            , m_accessCount(0)
             , m_previousInLiveResourcesList(0)
             , m_nextInLiveResourcesList(0)
             , m_previousInAllResourcesList(0)
             , m_nextInAllResourcesList(0)
         {
         }
     };
 
     struct LRUList {
         MemoryCacheEntry* m_head;
@@ skipping 33 matching lines @@
         TypeStatistic xslStyleSheets;
         TypeStatistic fonts;
         TypeStatistic other;
     };
 
     Resource* resourceForURL(const KURL&);
 
     void add(Resource*);
     void replace(Resource* newResource, Resource* oldResource);
     void remove(Resource* resource) { evict(resource); }
+    bool contains(Resource*);
 
     static KURL removeFragmentIdentifierIfNeeded(const KURL& originalURL);
 
     // Sets the cache's memory capacities, in bytes. These will hold only approximately,
     // since the decoded cost of resources like scripts and stylesheets is not known.
     //  - minDeadBytes: The maximum number of bytes that dead resources should consume when the cache is under pressure.
     //  - maxDeadBytes: The maximum number of bytes that dead resources should consume when the cache is not under pressure.
     //  - totalBytes: The maximum number of bytes that the cache should consume overall.
     void setCapacities(size_t minDeadBytes, size_t maxDeadBytes, size_t totalBytes);
     void setDelayBeforeLiveDecodedPrune(double seconds) { m_delayBeforeLiveDecodedPrune = seconds; }
     void setMaxPruneDeferralDelay(double seconds) { m_maxPruneDeferralDelay = seconds; }
 
     void evictResources();
 
     void prune(Resource* justReleasedResource = 0);
 
-    // Calls to put the cached resource into and out of LRU lists.
-    void insertInLRUList(Resource*);
-    void removeFromLRUList(Resource*);
-
-    // Called to adjust the cache totals when a resource changes size.
-    void adjustSize(bool live, ptrdiff_t delta);
+    // Called to adjust a resource's size, lru list position, and access count.
+    void update(Resource*, size_t oldSize, size_t newSize, bool wasAccessed = false);
+    void updateForAccess(Resource* resource) { update(resource, resource->size(), resource->size(), true); }
 
     // Track decoded resources that are in the cache and referenced by a Web page.
     void insertInLiveDecodedResourcesList(Resource*);
     void removeFromLiveDecodedResourcesList(Resource*);
     bool isInLiveDecodedResourcesList(Resource*);
 
     void addToLiveResourcesSize(Resource*);
     void removeFromLiveResourcesSize(Resource*);
 
     static void removeURLFromCache(ExecutionContext*, const KURL&);
 
     Statistics getStatistics();
 
     size_t minDeadCapacity() const { return m_minDeadCapacity; }
     size_t maxDeadCapacity() const { return m_maxDeadCapacity; }
     size_t capacity() const { return m_capacity; }
     size_t liveSize() const { return m_liveSize; }
     size_t deadSize() const { return m_deadSize; }
 
     // TaskObserver implementation
     virtual void willProcessTask() OVERRIDE;
     virtual void didProcessTask() OVERRIDE;
 
 private:
-    LRUList* lruListFor(MemoryCacheEntry*);
+    LRUList* lruListFor(unsigned accessCount, size_t);
 
 #ifdef MEMORY_CACHE_STATS
     void dumpStats(Timer<MemoryCache>*);
     void dumpLRULists(bool includeLive) const;
 #endif
 
+    // Calls to put the cached resource into and out of LRU lists.
+    void insertInLRUList(MemoryCacheEntry*, LRUList*);
+    void removeFromLRUList(MemoryCacheEntry*, LRUList*);
+
     size_t liveCapacity() const;
     size_t deadCapacity() const;
 
     // pruneDeadResources() - Flush decoded and encoded data from resources not referenced by Web pages.
     // pruneLiveResources() - Flush decoded data from resources still referenced by Web pages.
     void pruneDeadResources(); // Automatically decide how much to prune.
     void pruneLiveResources();
     void pruneNow(double currentTime);
 
     bool evict(Resource*);
@@ skipping 37 matching lines @@
 
 // Returns the global cache.
 MemoryCache* memoryCache();
 
 // Sets the global cache, used to swap in a test instance.
 void setMemoryCacheForTesting(MemoryCache*);
 
 }
 
 #endif