Make Resource RefCountedWillBeGarbageCollectedFinalized, attempt #2

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 13 matching lines @@
 #include "core/fetch/Resource.h"
 
 #include "core/fetch/CachedMetadata.h"
 #include "core/fetch/CrossOriginAccessControl.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceClient.h"
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
-#include "core/fetch/ResourcePtr.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "platform/Logging.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebProcessMemoryDump.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
@@ skipping 103 matching lines @@
     : m_resourceRequest(request)
     , m_responseTimestamp(currentTime())
     , m_cancelTimer(this, &Resource::cancelTimerFired)
 #if !ENABLE(OILPAN)
     , m_weakPtrFactory(this)
 #endif
     , m_loadFinishTime(0)
     , m_identifier(0)
     , m_encodedSize(0)
     , m_decodedSize(0)
-    , m_handleCount(0)
     , m_preloadCount(0)
-    , m_protectorCount(0)
     , m_cacheIdentifier(MemoryCache::defaultCacheIdentifier())
     , m_preloadResult(PreloadNotReferenced)
     , m_requestedFromNetworkingLayer(false)
     , m_loading(false)
-    , m_switchingClientsToRevalidatedResource(false)
     , m_type(type)
     , m_status(Pending)
-    , m_wasPurged(false)
     , m_needsSynchronousCacheHit(false)
     , m_linkPreload(false)
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     , m_deleted(false)
 #endif
 {
     ASSERT(m_type == unsigned(type)); // m_type is a bitfield, so this tests careless updates of the enum.
     InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
-    memoryCache()->registerLiveResource(*this);
 
     // Currently we support the metadata caching only for HTTP family.
     if (m_resourceRequest.url().protocolIsInHTTPFamily())
         m_cacheHandler = CacheHandler::create(this);
 
     if (!m_resourceRequest.url().hasFragmentIdentifier())
         return;
     KURL urlForCache = MemoryCache::removeFragmentIdentifierIfNeeded(m_resourceRequest.url());
     if (urlForCache.hasFragmentIdentifier())
         return;
     m_fragmentIdentifierForRequest = m_resourceRequest.url().fragmentIdentifier();
     m_resourceRequest.setURL(urlForCache);
 }
 
 Resource::~Resource()
 {
-    ASSERT(canDelete());
-    RELEASE_ASSERT(!memoryCache()->contains(this));
-    RELEASE_ASSERT(!ResourceCallback::callbackHandler()->isScheduled(this));
     assertAlive();
 
 #ifdef ENABLE_RESOURCE_IS_DELETED_CHECK
     m_deleted = true;
 #endif
+
     InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
 }
 
-void Resource::dispose()
+void Resource::removedFromMemoryCache()
 {
+    InspectorInstrumentation::removedResourceFromMemoryCache(this);
 }
 
 DEFINE_TRACE(Resource)
 {
     visitor->trace(m_loader);
 #if ENABLE(OILPAN)
     visitor->trace(m_cacheHandler);
 #endif
 }
 
@@ skipping 222 matching lines @@
 }
 
 bool Resource::unlock()
 {
     if (!m_data)
         return false;
 
     if (!m_data->isLocked())
         return true;
 
-    if (!memoryCache()->contains(this) || hasClients() || m_handleCount > 1 || !m_revalidatingRequest.isNull() || !m_loadFinishTime || !isSafeToUnlock())
+    if (!memoryCache()->contains(this) || hasClients() || !m_revalidatingRequest.isNull() || !m_loadFinishTime || !isSafeToUnlock())
         return false;
 
     m_data->unlock();
     return true;
 }
 
-bool Resource::hasRightHandleCountApartFromCache(unsigned targetCount) const
-{
-    return m_handleCount == targetCount + (memoryCache()->contains(this) ? 1 : 0);
-}
-
 void Resource::responseReceived(const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle>)
 {
     m_responseTimestamp = currentTime();
 
     if (!m_revalidatingRequest.isNull()) {
         if (response.httpStatusCode() == 304) {
             revalidationSucceeded(response);
             return;
         }
         revalidationFailed();
@@ skipping 51 matching lines @@
 
 WeakPtrWillBeRawPtr<Resource> Resource::asWeakPtr()
 {
 #if ENABLE(OILPAN)
     return this;
 #else
     return m_weakPtrFactory.createWeakPtr();
 #endif
 }
 
-bool Resource::canDelete() const
-{
-    return !hasClients() && !m_loader && !m_preloadCount && hasRightHandleCountApartFromCache(0)
-        && !m_protectorCount;
-}
-
 String Resource::reasonNotDeletable() const
 {
     StringBuilder builder;
     if (hasClients()) {
         builder.append("hasClients(");
         builder.appendNumber(m_clients.size());
         if (!m_clientsAwaitingCallback.isEmpty()) {
             builder.append(", AwaitingCallback=");
             builder.appendNumber(m_clientsAwaitingCallback.size());
         }
         if (!m_finishedClients.isEmpty()) {
             builder.append(", Finished=");
             builder.appendNumber(m_finishedClients.size());
         }
         builder.append(")");
     }
     if (m_loader) {
         if (!builder.isEmpty())
             builder.append(' ');
         builder.append("m_loader");
     }
     if (m_preloadCount) {
         if (!builder.isEmpty())
             builder.append(' ');
         builder.append("m_preloadCount(");
         builder.appendNumber(m_preloadCount);
         builder.append(")");
     }
-    if (!hasRightHandleCountApartFromCache(0)) {
-        if (!builder.isEmpty())
-            builder.append(' ');
-        builder.append("m_handleCount(");
-        builder.appendNumber(m_handleCount);
-        builder.append(")");
-    }
-    if (m_protectorCount) {
-        if (!builder.isEmpty())
-            builder.append(' ');
-        builder.append("m_protectorCount(");
-        builder.appendNumber(m_protectorCount);
-        builder.append(")");
-    }
     if (memoryCache()->contains(this)) {
         if (!builder.isEmpty())
             builder.append(' ');
         builder.append("in_memory_cache");
     }
     return builder.toString();
 }
 
-bool Resource::hasOneHandle() const
-{
-    return hasRightHandleCountApartFromCache(1);
-}
-
 CachedMetadata* Resource::cachedMetadata(unsigned dataTypeID) const
 {
     if (!m_cachedMetadata || m_cachedMetadata->dataTypeID() != dataTypeID)
         return nullptr;
     return m_cachedMetadata.get();
 }
 
 void Resource::clearLoader()
 {
     m_loader = nullptr;
@@ skipping 69 matching lines @@
     else if (m_clientsAwaitingCallback.contains(client))
         m_clientsAwaitingCallback.remove(client);
     else
         m_clients.remove(client);
 
     didRemoveClient(client);
 
     if (m_clientsAwaitingCallback.isEmpty())
         ResourceCallback::callbackHandler()->cancel(this);
 
-    bool deleted = deleteIfPossible();
-    if (!deleted && !hasClients()) {
+    if (!hasClients()) {
+        RefPtrWillBeRawPtr<Resource> protect(this);
         memoryCache()->makeDead(this);
-        if (!m_switchingClientsToRevalidatedResource)
-            allClientsRemoved();
+        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();
         } else {
             memoryCache()->prune(this);
         }
     }
     // This object may be dead here.
 }
 
 void Resource::allClientsRemoved()
 {
     if (!m_loader)
         return;
-    if (m_type == MainResource || m_type == Raw)
+    if (m_type == MainResource || m_type == Raw || !memoryCache()->contains(this))
         cancelTimerFired(&m_cancelTimer);
     else if (!m_cancelTimer.isActive())
         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;
-    ResourcePtr<Resource> protect(this);
+    RefPtrWillBeRawPtr<Resource> protect(this);
     m_loader->cancelIfNotFinishing();
     if (m_status != Cached)
         memoryCache()->remove(this);
 }
 
-bool Resource::deleteIfPossible()
-{
-    if (canDelete() && !memoryCache()->contains(this)) {
-        InspectorInstrumentation::willDestroyResource(this);
-        dispose();
-        memoryCache()->unregisterLiveResource(*this);
-#if !ENABLE(OILPAN)
-        delete this;
-#endif
-        return true;
-    }
-    return false;
-}
-
 void Resource::setDecodedSize(size_t decodedSize)
 {
     if (decodedSize == m_decodedSize)
         return;
     size_t oldSize = size();
     m_decodedSize = decodedSize;
     memoryCache()->update(this, oldSize, size());
     memoryCache()->updateDecodedResource(this, UpdateForPropertyChange);
 }
 
@@ skipping 51 matching lines @@
 }
 
 void Resource::onMemoryDump(WebMemoryDumpLevelOfDetail levelOfDetail, WebProcessMemoryDump* memoryDump) const
 {
     static const size_t kMaxURLReportLength = 128;
     static const int kMaxResourceClientToShowInMemoryInfra = 10;
 
     const String dumpName = getMemoryDumpName();
     WebMemoryAllocatorDump* dump = memoryDump->createMemoryAllocatorDump(dumpName);
     dump->addScalar("encoded_size", "bytes", m_encodedSize);
-    if (canDelete()) {
+    if (m_data && m_data->isLocked())
+        dump->addScalar("live_size", "bytes", m_encodedSize);
+    else
         dump->addScalar("dead_size", "bytes", m_encodedSize);
-    } else {
-        dump->addScalar("live_size", "bytes", m_encodedSize);
-    }
 
     if (m_data) {
-        dump->addScalar("purgeable_size", "bytes", isPurgeable() && !wasPurged() ? encodedSize() + overheadSize() : 0);
+        dump->addScalar("purgeable_size", "bytes", isPurgeable() ? encodedSize() + overheadSize() : 0);
         m_data->onMemoryDump(dumpName, memoryDump);
     }
 
     if (levelOfDetail == WebMemoryDumpLevelOfDetail::Detailed) {
         String urlToReport = url().string();
         if (urlToReport.length() > kMaxURLReportLength) {
             urlToReport.truncate(kMaxURLReportLength);
             urlToReport = urlToReport + "...";
         }
         dump->addString("url", "", urlToReport);
@@ skipping 61 matching lines @@
 }
 
 void Resource::revalidationFailed()
 {
     m_resourceRequest = m_revalidatingRequest;
     m_revalidatingRequest = ResourceRequest();
     m_data.clear();
     destroyDecodedDataForFailedRevalidation();
 }
 
-void Resource::registerHandle(ResourcePtrBase* h)
-{
-    assertAlive();
-    ++m_handleCount;
-}
-
-void Resource::unregisterHandle(ResourcePtrBase* h)
-{
-    assertAlive();
-    ASSERT(m_handleCount > 0);
-    --m_handleCount;
-
-    if (!m_handleCount) {
-        if (deleteIfPossible())
-            return;
-        unlock();
-    } else if (m_handleCount == 1 && memoryCache()->contains(this)) {
-        unlock();
-        if (!hasClients())
-            memoryCache()->prune(this);
-    }
-}
-
 bool Resource::canReuseRedirectChain()
 {
     for (auto& redirect : m_redirectChain) {
         if (!canUseResponse(redirect.m_redirectResponse, m_responseTimestamp))
             return false;
         if (redirect.m_request.cacheControlContainsNoCache() || redirect.m_request.cacheControlContainsNoStore())
             return false;
     }
     return true;
 }
@@ skipping 21 matching lines @@
     if (hasCacheControlNoStoreHeader())
         return false;
     return m_response.hasCacheValidatorFields() || m_resourceRequest.hasCacheValidatorFields();
 }
 
 bool Resource::isPurgeable() const
 {
     return m_data && !m_data->isLocked();
 }
 
-bool Resource::wasPurged() const
-{
-    return m_wasPurged;
-}
-
 bool Resource::lock()
 {
     if (!m_data)
         return true;
     if (m_data->isLocked())
         return true;
 
     ASSERT(!hasClients());
 
+    // If locking fails, our buffer has been purged. There's no point
+    // in leaving a purged resource in MemoryCache.
     if (!m_data->lock()) {
-        m_wasPurged = true;
+        memoryCache()->remove(this);
         return false;
     }
     return true;
 }
 
 size_t Resource::overheadSize() const
 {
     static const int kAverageClientsHashMapSize = 384;
     return sizeof(Resource) + m_response.memoryUsage() + kAverageClientsHashMapSize + m_resourceRequest.url().string().length() * 2;
 }
@@ skipping 59 matching lines @@
         m_callbackTaskFactory->cancel();
 }
 
 bool Resource::ResourceCallback::isScheduled(Resource* resource) const
 {
     return m_resourcesWithPendingClients.contains(resource);
 }
 
 void Resource::ResourceCallback::runTask()
 {
-    Vector<ResourcePtr<Resource>> resources;
-    for (const RawPtrWillBeMember<Resource>& resource : m_resourcesWithPendingClients)
+    WillBeHeapVector<RefPtrWillBeMember<Resource>> resources;
+    for (const RefPtrWillBeMember<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