void MemoryCache::replace(Resource* newResource, Resource* oldResource)
{
evict(oldResource);
ASSERT(!m_resources.get(newResource->url()));
m_resources.set(newResource->url(), newResource);
newResource->setInCache(true);
insertInLRUList(newResource);
int delta = newResource->size();
if (newResource->decodedSize() && newResource->hasClients())
insertInLiveDecodedResourcesList(newResource);
if (delta)
adjustSize(newResource->hasClients(), delta);
}
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();
}
void MemoryCache::revalidationSucceeded(CachedResource& revalidatingResource, const ResourceResponse& response)
{
ASSERT(revalidatingResource.resourceToRevalidate());
CachedResource& resource = *revalidatingResource.resourceToRevalidate();
ASSERT(!resource.inCache());
ASSERT(resource.isLoaded());
// Calling remove() 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());
remove(revalidatingResource);
auto& resources = ensureSessionResourceMap(resource.sessionID());
#if ENABLE(CACHE_PARTITIONING)
auto key = std::make_pair(resource.url(), resource.cachePartition());
#else
auto& key = resource.url();
#endif
ASSERT(!resources.get(key));
resources.set(key, &resource);
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();
}
void MemoryCache::update(Resource* resource, size_t oldSize, size_t newSize, bool wasAccessed)
{
MemoryCacheEntry* entry = getEntryForResource(resource);
if (!entry)
return;
// The object must now be moved to a different queue, since either its size or its accessCount has been changed,
// and both of those are used to determine which LRU queue the resource should be in.
if (oldSize)
removeFromLRUList(entry, lruListFor(entry->m_accessCount, oldSize));
if (wasAccessed)
entry->m_accessCount++;
if (newSize)
insertInLRUList(entry, lruListFor(entry->m_accessCount, newSize));
ptrdiff_t delta = newSize - oldSize;
if (resource->hasClients()) {
ASSERT(delta >= 0 || m_liveSize >= static_cast<size_t>(-delta) );
m_liveSize += delta;
} else {
ASSERT(delta >= 0 || m_deadSize >= static_cast<size_t>(-delta) );
m_deadSize += delta;
}
}
