Make Resource RefCountedWillBeGarbageCollectedFinalized, attempt #2

third_party/WebKit/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.
 
     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.
 
     This class provides all functionality needed for loading images, style sheets and html
     pages from the web. It has a memory cache for these objects.
 */
 
 #ifndef MemoryCache_h
 #define MemoryCache_h
 
 #include "core/CoreExport.h"
 #include "core/fetch/Resource.h"
-#include "core/fetch/ResourcePtr.h"
 #include "public/platform/WebMemoryDumpProvider.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink  {
@@ skipping 36 matching lines @@
 // from MemoryCacheLRUList.
 class MemoryCacheEntry final : public GarbageCollectedFinalized<MemoryCacheEntry> {
 public:
     static MemoryCacheEntry* create(Resource* resource)
     {
         return new MemoryCacheEntry(resource);
     }
     DECLARE_TRACE();
     void dispose();
 
-    ResourcePtr<Resource> m_resource;
+    RefPtrWillBeMember<Resource> m_resource;
     bool m_inLiveDecodedResourcesList;
     unsigned m_accessCount;
     MemoryCacheLiveResourcePriority m_liveResourcePriority;
     double m_lastDecodedAccessTime; // Used as a thrash guard
 
     Member<MemoryCacheEntry> m_previousInLiveResourcesList;
     Member<MemoryCacheEntry> m_nextInLiveResourcesList;
     Member<MemoryCacheEntry> m_previousInAllResourcesList;
     Member<MemoryCacheEntry> m_nextInAllResourcesList;
 
@@ skipping 168 matching lines @@
 
     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(PruneStrategy);
     void pruneLiveResources(PruneStrategy);
     void pruneNow(double currentTime, PruneStrategy);
 
-    bool evict(MemoryCacheEntry*);
+    void evict(MemoryCacheEntry*);
 
     MemoryCacheEntry* getEntryForResource(const Resource*) const;
 
     static void removeURLFromCacheInternal(ExecutionContext*, const KURL&);
 
     bool m_inPruneResources;
     bool m_prunePending;
     double m_maxPruneDeferralDelay;
     double m_pruneTimeStamp;
     double m_pruneFrameTimeStamp;
@@ skipping 17 matching lines @@
     // 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).
     using ResourceMap = HeapHashMap<String, Member<MemoryCacheEntry>>;
     using ResourceMapIndex = HeapHashMap<String, Member<ResourceMap>>;
     ResourceMap* ensureResourceMap(const String& cacheIdentifier);
     ResourceMapIndex m_resourceMaps;
 
-#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;
-    friend CORE_EXPORT MemoryCache* replaceMemoryCacheForTesting(MemoryCache*);
-#endif
-
     friend class MemoryCacheTest;
 #ifdef MEMORY_CACHE_STATS
     Timer<MemoryCache> m_statsTimer;
 #endif
 };
 
 // Returns the global cache.
 CORE_EXPORT MemoryCache* memoryCache();
 
 // Sets the global cache, used to swap in a test instance. Returns the old
 // MemoryCache object.
 CORE_EXPORT MemoryCache* replaceMemoryCacheForTesting(MemoryCache*);
 
 } // namespace blink
 
 #endif