Oilpan: Prepare to move Resource to Oilpan heap.

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 177 matching lines @@
     void evictResources();
 
     void prune(Resource* justReleasedResource = 0);
 
     // 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); }
     void updateDecodedResource(Resource*, UpdateReason, MemoryCacheLiveResourcePriority = MemoryCacheLiveResourcePriorityUnknown);
 
     void makeLive(Resource*);
     void makeDead(Resource*);

[haraken, 2014/07/28 07:43:52]

Just help me understand: Do we need to distinguish makeLive/makeDead and
registerLiveResource/unregisterLiveResource? (i.e., what's a difference from the
perspective of when these methods are called?)

[tkent, 2014/07/28 08:14:19]

'Live' / 'Dead' in these functions mean 'has one or more ResourceClient or not'.
 It's different from Resource lifetime.  MemoryCache::m_allResources also has
different scope.

 
+    // This should be called when a Resource object is created.
+    void registerLiveResource(Resource&);
+    // This should be called when a Resource object becomes unnecesarry.
+    void unregisterLiveResource(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; }
 
@@ skipping 57 matching lines @@
 
     // Lists just for live resources with decoded data. Access to this list is based off of painting the resource.
     // The lists are ordered by decode priority, with higher indices having higher priorities.
     MemoryCacheLRUList m_liveDecodedResources[MemoryCacheLiveResourcePriorityHigh + 1];
 
     // A URL-based map of all resources that are in the cache (including the freshest version of objects that are currently being
     // referenced by a Web page).
     typedef WillBeHeapHashMap<String, OwnPtrWillBeMember<MemoryCacheEntry> > ResourceMap;
     ResourceMap m_resources;
 
+#if ENABLE(OILPAN)
+    // Unlike m_allResources, m_liveResources is a set of Resource objects which
+    // should not be deleted. m_allResources only contains on-cache Resource
+    // objects.
+    // FIXME: Can we remove manual lifetime management of Resource and this?
+    HeapHashSet<Member<Resource> > m_liveResources;
+#endif
+
     friend class MemoryCacheTest;
 #ifdef MEMORY_CACHE_STATS
     Timer<MemoryCache> m_statsTimer;
 #endif
 };
 
 // Returns the global cache.
 MemoryCache* memoryCache();
 
 // Sets the global cache, used to swap in a test instance. Returns the old
 // MemoryCache object.
 PassOwnPtrWillBeRawPtr<MemoryCache> replaceMemoryCacheForTesting(PassOwnPtrWillBeRawPtr<MemoryCache>);
 
 }
 
 #endif