void MemoryCache::TypeStatistic::addResource(CachedResource& resource)
{
count++;
size += resource.size();
liveSize += resource.hasClients() ? resource.size() : 0;
decodedSize += resource.decodedSize();
}
void MemoryCache::remove(CachedResource& resource)
{
ASSERT(WTF::isMainThread());
LOG(ResourceLoading, "Evicting resource %p for '%s' from cache", &resource, resource.url().string().latin1().data());
// The resource may have already been removed by someone other than our caller,
// who needed a fresh copy for a reload. See <http://bugs.webkit.org/show_bug.cgi?id=12479#c6>.
if (auto* resources = sessionResourceMap(resource.sessionID())) {
#if ENABLE(CACHE_PARTITIONING)
auto key = std::make_pair(resource.url(), resource.cachePartition());
#else
auto& key = resource.url();
#endif
if (resource.inCache()) {
// Remove resource from the resource map.
resources->remove(key);
resource.setInCache(false);
// If the resource map is now empty, remove it from m_sessionResources.
if (resources->isEmpty())
m_sessionResources.remove(resource.sessionID());
// Remove from the appropriate LRU list.
removeFromLRUList(resource);
removeFromLiveDecodedResourcesList(resource);
adjustSize(resource.hasClients(), -static_cast<int>(resource.size()));
} else
ASSERT(resources->get(key) != &resource);
}
resource.deleteIfPossible();
}
void MemoryCache::resourceAccessed(CachedResource& resource)
{
ASSERT(resource.inCache());
// Need to make sure to remove before we increase the access count, since
// the queue will possibly change.
removeFromLRUList(resource);
// If this is the first time the resource has been accessed, adjust the size of the cache to account for its initial size.
if (!resource.accessCount())
adjustSize(resource.hasClients(), resource.size());
// Add to our access count.
resource.increaseAccessCount();
// Now insert into the new queue.
insertInLRUList(resource);
}
void MemoryCache::revalidationSucceeded(CachedResource* revalidatingResource, const ResourceResponse& response)
{
CachedResource* resource = revalidatingResource->resourceToRevalidate();
ASSERT(resource);
ASSERT(!resource->inCache());
ASSERT(resource->isLoaded());
ASSERT(revalidatingResource->inCache());
// Calling evict() can potentially delete revalidatingResource, which we use
// below. This mustn't be the case since revalidation means it is loaded
// and so canDelete() is false.
ASSERT(!revalidatingResource->canDelete());
evict(revalidatingResource);
CachedResourceMap& resources = getSessionMap(resource->sessionID());
#if ENABLE(CACHE_PARTITIONING)
ASSERT(!resources.get(resource->url()) || !resources.get(resource->url())->get(resource->cachePartition()));
CachedResourceItem* originMap = resources.get(resource->url());
if (!originMap) {
originMap = new CachedResourceItem;
resources.set(resource->url(), adoptPtr(originMap));
}
originMap->set(resource->cachePartition(), resource);
#else
ASSERT(!resources.get(resource->url()));
resources.set(resource->url(), resource);
#endif
resource->setInCache(true);
resource->updateResponseAfterRevalidation(response);
insertInLRUList(resource);
int delta = resource->size();
if (resource->decodedSize() && resource->hasClients())
insertInLiveDecodedResourcesList(resource);
if (delta)
adjustSize(resource->hasClients(), delta);
revalidatingResource->switchClientsToRevalidatedResource();
ASSERT(!revalidatingResource->m_deleted);
// this deletes the revalidating resource
revalidatingResource->clearResourceToRevalidate();
}
CachedResource* MemoryCache::resourceForRequest(const ResourceRequest& request)
{
ASSERT(WTF::isMainThread());
KURL url = removeFragmentIdentifierIfNeeded(request.url());
#if ENABLE(CACHE_PARTITIONING)
CachedResourceItem* item = m_resources.get(url);
CachedResource* resource = 0;
if (item)
resource = item->get(request.cachePartition());
#else
CachedResource* resource = m_resources.get(url);
#endif
bool wasPurgeable = MemoryCache::shouldMakeResourcePurgeableOnEviction() && resource && resource->isPurgeable();
if (resource && !resource->makePurgeable(false)) {
ASSERT(!resource->hasClients());
evict(resource);
return 0;
}
// Add the size back since we had subtracted it when we marked the memory as purgeable.
if (wasPurgeable)
adjustSize(resource->hasClients(), resource->size());
return resource;
}
void MemoryCache::removeFromLiveResourcesSize(CachedResource& resource)
{
m_liveSize -= resource.size();
m_deadSize += resource.size();
}
void MemoryCache::addToLiveResourcesSize(CachedResource& resource)
{
m_liveSize += resource.size();
m_deadSize -= resource.size();
}
