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; } }