Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/fetch/Resource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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
@@ skipping 75 matching lines @@
     }
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(headerPrefixesToIgnoreAfterRevalidation); i++) {
         if (header.startsWith(headerPrefixesToIgnoreAfterRevalidation[i], TextCaseInsensitive))
             return false;
     }
     return true;
 }
 
 class Resource::CacheHandler : public CachedMetadataHandler {
 public:
-    static PassOwnPtrWillBeRawPtr<CacheHandler> create(Resource* resource)
+    static RawPtr<CacheHandler> create(Resource* resource)
     {
-        return adoptPtrWillBeNoop(new CacheHandler(resource));
+        return (new CacheHandler(resource));
     }
     ~CacheHandler() override { }
     DECLARE_VIRTUAL_TRACE();
     void setCachedMetadata(unsigned, const char*, size_t, CacheType) override;
     void clearCachedMetadata(CacheType) override;
     CachedMetadata* cachedMetadata(unsigned) const override;
     String encoding() const override;
 
 private:
     explicit CacheHandler(Resource*);
-    RawPtrWillBeMember<Resource> m_resource;
+    Member<Resource> m_resource;
 };
 
 Resource::CacheHandler::CacheHandler(Resource* resource)
     : m_resource(resource)
 {
 }
 
 DEFINE_TRACE(Resource::CacheHandler)
 {
 #if ENABLE(OILPAN)
@@ skipping 380 matching lines @@
 }
 
 void Resource::clearCachedMetadata(CachedMetadataHandler::CacheType cacheType)
 {
     m_cachedMetadata.clear();
 
     if (cacheType == CachedMetadataHandler::SendToPlatform)
         Platform::current()->cacheMetadata(m_response.url(), m_response.responseTime(), 0, 0);
 }
 
-WeakPtrWillBeRawPtr<Resource> Resource::asWeakPtr()
+RawPtr<Resource> Resource::asWeakPtr()
 {
 #if ENABLE(OILPAN)
     return this;
 #else
     return m_weakPtrFactory.createWeakPtr();
 #endif
 }
 
 String Resource::reasonNotDeletable() const
 {
@@ skipping 114 matching lines @@
         m_clientsAwaitingCallback.remove(client);
     else
         m_clients.remove(client);
 
     didRemoveClient(client);
 
     if (m_clientsAwaitingCallback.isEmpty())
         ResourceCallback::callbackHandler()->cancel(this);
 
     if (!hasClients()) {
-        RefPtrWillBeRawPtr<Resource> protect(this);
+        RawPtr<Resource> protect(this);
         memoryCache()->makeDead(this);
         allClientsRemoved();
 
         // RFC2616 14.9.2:
         // "no-store: ... MUST make a best-effort attempt to remove the information from volatile storage as promptly as possible"
         // "... History buffers MAY store such responses as part of their normal operation."
         // We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
         if (hasCacheControlNoStoreHeader() && url().protocolIs("https")) {
             memoryCache()->remove(this);
             memoryCache()->prune();
@@ skipping 14 matching lines @@
         m_cancelTimer.startOneShot(0, BLINK_FROM_HERE);
 
     unlock();
 }
 
 void Resource::cancelTimerFired(Timer<Resource>* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_cancelTimer);
     if (hasClients() || !m_loader)
         return;
-    RefPtrWillBeRawPtr<Resource> protect(this);
+    RawPtr<Resource> protect(this);
     m_loader->cancelIfNotFinishing();
     if (m_status != Cached)
         memoryCache()->remove(this);
 }
 
 void Resource::setDecodedSize(size_t decodedSize)
 {
     if (decodedSize == m_decodedSize)
         return;
     size_t oldSize = size();
@@ skipping 238 matching lines @@
 }
 
 Resource::ResourceCallback* Resource::ResourceCallback::callbackHandler()
 {
     // Oilpan + LSan: as the callbackHandler() singleton is used by Resource
     // and ResourcePtr finalizers, it cannot be released upon shutdown in
     // preparation for leak detection.
     //
     // Keep it out of LSan's reach instead.
     LEAK_SANITIZER_DISABLED_SCOPE;
-    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<ResourceCallback>, callbackHandler, (adoptPtrWillBeNoop(new ResourceCallback)));
+    DEFINE_STATIC_LOCAL(Persistent<ResourceCallback>, callbackHandler, ((new ResourceCallback)));
     return callbackHandler.get();
 }
 
 DEFINE_TRACE(Resource::ResourceCallback)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_resourcesWithPendingClients);
 #endif
 }
 
@@ skipping 18 matching lines @@
         m_callbackTaskFactory->cancel();
 }
 
 bool Resource::ResourceCallback::isScheduled(Resource* resource) const
 {
     return m_resourcesWithPendingClients.contains(resource);
 }
 
 void Resource::ResourceCallback::runTask()
 {
-    WillBeHeapVector<RefPtrWillBeMember<Resource>> resources;
-    for (const RefPtrWillBeMember<Resource>& resource : m_resourcesWithPendingClients)
+    HeapVector<Member<Resource>> resources;
+    for (const Member<Resource>& resource : m_resourcesWithPendingClients)
         resources.append(resource.get());
     m_resourcesWithPendingClients.clear();
 
     for (const auto& resource : resources) {
         resource->assertAlive();
         resource->finishPendingClients();
         resource->assertAlive();
     }
 
     for (const auto& resource : resources)
@@ skipping 121 matching lines @@
     case Resource::Media:
         return "Media";
     case Resource::Manifest:
         return "Manifest";
     }
     ASSERT_NOT_REACHED();
     return "Unknown";
 }
 
 } // namespace blink