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 PageCache::remove(HistoryItem* item)
{
// Safely ignore attempts to remove items not in the cache.
if (!item || !item->m_cachedPage)
return;
item->m_cachedPage.clear();
removeFromLRUList(item);
--m_size;
item->deref(); // Balanced in add().
}
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 CachingReader::freeChunk(Chunk* pChunk) {
int removed = m_allocatedChunks.remove(pChunk->chunk_number);
// We'll tolerate not being in allocatedChunks because sometime you free a
// chunk right after you allocated it.
if (removed > 1) {
qDebug() << "ERROR: freeChunk free'd a chunk that was multiply-allocated.";
}
// If this is the LRU chunk then set its previous LRU chunk to the LRU
if (m_lruChunk == pChunk) {
m_lruChunk = pChunk->prev_lru;
}
m_mruChunk = removeFromLRUList(pChunk, m_mruChunk);
pChunk->chunk_number = -1;
pChunk->length = 0;
m_freeChunks.push_back(pChunk);
}
void MemoryCache::evict(Resource* 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 (resource->inCache()) {
// Remove from the resource map.
m_resources.remove(resource->url());
resource->setInCache(false);
// Remove from the appropriate LRU list.
removeFromLRUList(resource);
removeFromLiveDecodedResourcesList(resource);
adjustSize(resource->hasClients(), -static_cast<int>(resource->size()));
} else
ASSERT(m_resources.get(resource->url()) != resource);
resource->deleteIfPossible();
}
std::unique_ptr<CachedPage> PageCache::take(HistoryItem* item)
{
if (!item)
return nullptr;
std::unique_ptr<CachedPage> cachedPage = WTF::move(item->m_cachedPage);
removeFromLRUList(item);
--m_size;
item->deref(); // Balanced in add().
if (!cachedPage)
return nullptr;
if (cachedPage->hasExpired()) {
LOG(PageCache, "Not restoring page for %s from back/forward cache because cache entry has expired", item->url().string().ascii().data());
return nullptr;
}
return cachedPage;
}
void MemoryCache::evict(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 (resource->inCache()) {
// Remove from the resource map.
#if ENABLE(CACHE_PARTITIONING)
CachedResourceItem* item = m_resources.get(resource->url());
if (item) {
item->remove(resource->cachePartition());
if (!item->size())
m_resources.remove(resource->url());
}
#else
m_resources.remove(resource->url());
#endif
resource->setInCache(false);
// Remove from the appropriate LRU list.
removeFromLRUList(resource);
removeFromLiveDecodedResourcesList(resource);
// If the resource was purged, it means we had already decremented the size when we made the
// resource purgeable in makeResourcePurgeable(). So adjust the size if we are evicting a
// resource that was not marked as purgeable.
if (!MemoryCache::shouldMakeResourcePurgeableOnEviction() || !resource->isPurgeable())
adjustSize(resource->hasClients(), -static_cast<int>(resource->size()));
} else
#if ENABLE(CACHE_PARTITIONING)
ASSERT(!m_resources.get(resource->url()) || m_resources.get(resource->url())->get(resource->cachePartition()) != resource);
#else
ASSERT(m_resources.get(resource->url()) != resource);
#endif
resource->deleteIfPossible();
}
Chunk* CachingReader::lookupChunk(int chunk_number) {
// Defaults to NULL if it's not in the hash.
Chunk* chunk = NULL;
if (m_allocatedChunks.contains(chunk_number)) {
chunk = m_allocatedChunks.value(chunk_number);
// Make sure we're all in agreement here.
if (chunk_number != chunk->chunk_number) {
qDebug() << "ERROR: Inconsistent chunk has chunk_number that doesn't match allocated-chunks key.";
}
// If this is the LRU chunk then set the previous LRU to the new LRU
if (chunk == m_lruChunk && chunk->prev_lru != NULL) {
m_lruChunk = chunk->prev_lru;
}
// Remove the chunk from the list and insert it at the head.
m_mruChunk = removeFromLRUList(chunk, m_mruChunk);
m_mruChunk = insertIntoLRUList(chunk, m_mruChunk);
}
return chunk;
}
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;
}
}
