[Oilpan] [Reland] Migrate classes under core/fetch 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 55 matching lines @@
 };
 
 enum UpdateReason {
     UpdateForAccess,
     UpdateForPropertyChange
 };
 
 // MemoryCacheEntry class is used only in MemoryCache class, but we don't make
 // MemoryCacheEntry class an inner class of MemoryCache because of dependency
 // from MemoryCacheLRUList.
-class MemoryCacheEntry final : public NoBaseWillBeGarbageCollectedFinalized<MemoryCacheEntry> {
+class MemoryCacheEntry final : public GarbageCollectedFinalized<MemoryCacheEntry> {
 public:
-    static PassOwnPtrWillBeRawPtr<MemoryCacheEntry> create(Resource* resource)
+    static MemoryCacheEntry* create(Resource* resource)
     {
-        return adoptPtrWillBeNoop(new MemoryCacheEntry(resource));
+        return new MemoryCacheEntry(resource);
     }
     DECLARE_TRACE();
-#if ENABLE(OILPAN)
     void dispose();
-#endif
 
     ResourcePtr<Resource> m_resource;
     bool m_inLiveDecodedResourcesList;
     unsigned m_accessCount;
     MemoryCacheLiveResourcePriority m_liveResourcePriority;
     double m_lastDecodedAccessTime; // Used as a thrash guard
 
-    RawPtrWillBeMember<MemoryCacheEntry> m_previousInLiveResourcesList;
-    RawPtrWillBeMember<MemoryCacheEntry> m_nextInLiveResourcesList;
-    RawPtrWillBeMember<MemoryCacheEntry> m_previousInAllResourcesList;
-    RawPtrWillBeMember<MemoryCacheEntry> m_nextInAllResourcesList;
+    Member<MemoryCacheEntry> m_previousInLiveResourcesList;
+    Member<MemoryCacheEntry> m_nextInLiveResourcesList;
+    Member<MemoryCacheEntry> m_previousInAllResourcesList;
+    Member<MemoryCacheEntry> m_nextInAllResourcesList;
 
 private:
     explicit MemoryCacheEntry(Resource* resource)
         : m_resource(resource)
         , m_inLiveDecodedResourcesList(false)
         , m_accessCount(0)
         , m_liveResourcePriority(MemoryCacheLiveResourcePriorityLow)
         , m_lastDecodedAccessTime(0.0)
         , m_previousInLiveResourcesList(nullptr)
         , m_nextInLiveResourcesList(nullptr)
         , m_previousInAllResourcesList(nullptr)
         , m_nextInAllResourcesList(nullptr)
     {
     }
 };
 
 WILL_NOT_BE_EAGERLY_TRACED_CLASS(MemoryCacheEntry);
 
 // MemoryCacheLRUList is used only in MemoryCache class, but we don't make
 // MemoryCacheLRUList an inner struct of MemoryCache because we can't define
 // VectorTraits for inner structs.
 struct MemoryCacheLRUList final {
     ALLOW_ONLY_INLINE_ALLOCATION();
 public:
-    RawPtrWillBeMember<MemoryCacheEntry> m_head;
-    RawPtrWillBeMember<MemoryCacheEntry> m_tail;
+    Member<MemoryCacheEntry> m_head;
+    Member<MemoryCacheEntry> m_tail;
 
     MemoryCacheLRUList() : m_head(nullptr), m_tail(nullptr) { }
     DECLARE_TRACE();
 };
 
 }
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(blink::MemoryCacheLRUList);
 
 namespace blink {
 
-class CORE_EXPORT MemoryCache final : public NoBaseWillBeGarbageCollectedFinalized<MemoryCache>, public WebThread::TaskObserver {
-    WTF_MAKE_NONCOPYABLE(MemoryCache); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(MemoryCache);
+class CORE_EXPORT MemoryCache final : public GarbageCollectedFinalized<MemoryCache>, public WebThread::TaskObserver {
+    WTF_MAKE_NONCOPYABLE(MemoryCache);
 public:
-    static PassOwnPtrWillBeRawPtr<MemoryCache> create();
+    static MemoryCache* create();
     ~MemoryCache();
     DECLARE_TRACE();
 
     struct TypeStatistic {
         int count;
         int size;
         int liveSize;
         int decodedSize;
         int encodedSize;
         int encodedSizeDuplicatedInDataURLs;
@@ skipping 138 matching lines @@
     size_t m_maxDeadCapacity;
     size_t m_maxDeferredPruneDeadCapacity;
     double m_delayBeforeLiveDecodedPrune;
 
     size_t m_liveSize; // The number of bytes currently consumed by "live" resources in the cache.
     size_t m_deadSize; // The number of bytes currently consumed by "dead" resources in the cache.
 
     // Size-adjusted and popularity-aware LRU list collection for cache objects. This collection can hold
     // more resources than the cached resource map, since it can also hold "stale" multiple versions of objects that are
     // waiting to die when the clients referencing them go away.
-    WillBeHeapVector<MemoryCacheLRUList, 32> m_allResources;
+    HeapVector<MemoryCacheLRUList, 32> m_allResources;
 
     // 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).
-    using ResourceMap = WillBeHeapHashMap<String, OwnPtrWillBeMember<MemoryCacheEntry>>;
-    using ResourceMapIndex = WillBeHeapHashMap<String, OwnPtrWillBeMember<ResourceMap>>;
+    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 RawPtr<MemoryCache> replaceMemoryCacheForTesting(RawPtr<MemoryCache>);
+    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 PassOwnPtrWillBeRawPtr<MemoryCache> replaceMemoryCacheForTesting(PassOwnPtrWillBeRawPtr<MemoryCache>);
+CORE_EXPORT MemoryCache* replaceMemoryCacheForTesting(MemoryCache*);
 
 }
 
 #endif