#include "config.h"
#include "Cache.h"
#include "CachedCSSStyleSheet.h"
#include "CachedImage.h"
#include "CachedScript.h"
#include "CachedXSLStyleSheet.h"
#include "DocLoader.h"
#include "Document.h"
#include "Image.h"
#include "TransferJob.h"
#include "loader.h"
using namespace std;
namespace WebCore {
const int cDefaultCacheSize = 8192 * 1024;
const int cDefaultLargeResourceSize = 80 * 1024;
Cache* cache()
{
static Cache cache;
return &cache;
}
Cache::Cache()
: m_disabled(false)
, m_maximumSize(cDefaultCacheSize)
, m_currentSize(0)
, m_liveResourcesSize(0)
, m_currentDecodedSize(0)
, m_liveDecodedSize(0)
{
}
static CachedResource* createResource(CachedResource::Type type, DocLoader* docLoader, const KURL& url, const DeprecatedString* charset)
{
switch (type) {
case CachedResource::ImageResource:
return new CachedImage(docLoader, url.url(), docLoader ? docLoader->cachePolicy() : CachePolicyCache);
case CachedResource::CSSStyleSheet:
return new CachedCSSStyleSheet(docLoader, url.url(), docLoader->cachePolicy(), *charset);
case CachedResource::Script:
return new CachedScript(docLoader, url.url(), docLoader->cachePolicy(), *charset);
#ifdef XSLT_SUPPORT
case CachedResource::XSLStyleSheet:
return new CachedXSLStyleSheet(docLoader, url.url(), docLoader->cachePolicy());
#endif
#ifdef XBL_SUPPORT
case CachedResource::XBLStyleSheet:
return new CachedXBLDocument(docLoader, url.url(), docLoader->cachePolicy());
#endif
default:
break;
}
return 0;
}
CachedResource* Cache::requestResource(DocLoader* docLoader, CachedResource::Type type, const KURL& url, const DeprecatedString* charset)
{
CachedResource* resource = m_resources.get(url.url());
if (!resource) {
resource = createResource(type, docLoader, url, charset);
ASSERT(resource);
resource->setInCache(!disabled());
if (!disabled())
m_resources.set(url.url(), resource); }
resourceAccessed(resource);
if (resource->type() != type)
return 0;
return resource;
}
CachedResource* Cache::resourceForURL(const String& url)
{
return m_resources.get(url);
}
void Cache::pruneLiveResources()
{
if (m_currentSize <= m_maximumSize)
return;
if (m_liveDecodedSize <= m_maximumSize)
return;
unsigned size = m_liveResources.size();
for (int i = size - 1; i >= 0; i--) {
CachedResource* current = m_liveResources[i].m_tail;
while (current) {
CachedResource* prev = current->m_prevInLiveResourcesList;
ASSERT(current->referenced());
if (current->isLoaded()) {
current->destroyDecodedData();
if (m_liveDecodedSize <= m_maximumSize)
return;
}
current = prev;
}
}
}
void Cache::pruneAllResources()
{
if (m_currentSize <= m_maximumSize)
return;
unsigned unreferencedResourcesSize = m_currentSize - m_liveResourcesSize;
if (unreferencedResourcesSize < m_maximumSize / 2U)
return;
unsigned size = m_allResources.size();
bool canShrinkLRULists = true;
for (int i = size - 1; i >= 0; i--) {
CachedResource* current = m_allResources[i].m_tail;
while (current) {
CachedResource* prev = current->m_prevInAllResourcesList;
if (!current->referenced()) {
current->destroyDecodedData();
if (m_currentSize <= m_maximumSize || m_currentSize == m_liveResourcesSize)
return;
}
current = prev;
}
current = m_allResources[i].m_tail;
while (current) {
CachedResource* prev = current->m_prevInAllResourcesList;
if (!current->referenced()) {
remove(current);
if (m_currentSize <= m_maximumSize || m_currentSize == m_liveResourcesSize)
return;
}
current = prev;
}
if (m_allResources[i].m_head)
canShrinkLRULists = false;
else if (canShrinkLRULists)
m_allResources.resize(i);
}
}
void Cache::setMaximumSize(int bytes)
{
m_maximumSize = bytes;
pruneAllResources();
}
void Cache::remove(CachedResource* resource)
{
if (resource->inCache()) {
m_resources.remove(resource->url());
resource->setInCache(false);
removeFromLRUList(resource);
if (resource->referenced())
removeFromLiveResourcesList(resource);
HashSet<DocLoader*>::iterator end = m_docLoaders.end();
for (HashSet<DocLoader*>::iterator itr = m_docLoaders.begin(); itr != end; ++itr)
(*itr)->removeCachedResource(resource);
int delta = -resource->size();
if (delta)
adjustSize(resource->referenced(), delta, -resource->decodedSize());
}
if (resource->canDelete())
delete resource;
}
void Cache::addDocLoader(DocLoader* docLoader)
{
m_docLoaders.add(docLoader);
}
void Cache::removeDocLoader(DocLoader* docLoader)
{
m_docLoaders.remove(docLoader);
}
static inline unsigned fastLog2(unsigned i)
{
unsigned log2 = 0;
if (i & (i - 1))
log2 += 1;
if (i >> 16)
log2 += 16, i >>= 16;
if (i >> 8)
log2 += 8, i >>= 8;
if (i >> 4)
log2 += 4, i >>= 4;
if (i >> 2)
log2 += 2, i >>= 2;
if (i >> 1)
log2 += 1;
return log2;
}
LRUList* Cache::lruListFor(CachedResource* resource)
{
unsigned accessCount = max(resource->accessCount(), 1U);
unsigned queueIndex = fastLog2(resource->encodedSize() / accessCount);
#ifndef NDEBUG
resource->m_lruIndex = queueIndex;
#endif
if (m_allResources.size() <= queueIndex)
m_allResources.resize(queueIndex + 1);
return &m_allResources[queueIndex];
}
void Cache::removeFromLRUList(CachedResource* resource)
{
if (resource->accessCount() == 0)
return;
#ifndef NDEBUG
unsigned oldListIndex = resource->m_lruIndex;
#endif
LRUList* list = lruListFor(resource);
#ifndef NDEBUG
ASSERT(resource->m_lruIndex == oldListIndex);
bool found = false;
for (CachedResource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
if (current == resource) {
found = true;
break;
}
}
ASSERT(found);
#endif
CachedResource* next = resource->m_nextInAllResourcesList;
CachedResource* prev = resource->m_prevInAllResourcesList;
if (next == 0 && prev == 0 && list->m_head != resource)
return;
resource->m_nextInAllResourcesList = 0;
resource->m_prevInAllResourcesList = 0;
if (next)
next->m_prevInAllResourcesList = prev;
else if (list->m_tail == resource)
list->m_tail = prev;
if (prev)
prev->m_nextInAllResourcesList = next;
else if (list->m_head == resource)
list->m_head = next;
}
void Cache::insertInLRUList(CachedResource* resource)
{
ASSERT(!resource->m_nextInAllResourcesList && !resource->m_prevInAllResourcesList);
LRUList* list = lruListFor(resource);
resource->m_nextInAllResourcesList = list->m_head;
if (list->m_head)
list->m_head->m_prevInAllResourcesList = resource;
list->m_head = resource;
if (!resource->m_nextInAllResourcesList)
list->m_tail = resource;
#ifndef NDEBUG
list = lruListFor(resource);
bool found = false;
for (CachedResource* current = list->m_head; current; current = current->m_nextInAllResourcesList) {
if (current == resource) {
found = true;
break;
}
}
ASSERT(found);
#endif
}
void Cache::resourceAccessed(CachedResource* resource)
{
removeFromLRUList(resource);
resource->increaseAccessCount();
insertInLRUList(resource);
}
LRUList* Cache::liveLRUListFor(CachedResource* resource)
{
unsigned accessCount = max(resource->liveAccessCount(), 1U);
unsigned queueIndex = fastLog2(resource->decodedSize() / accessCount);
#ifndef NDEBUG
resource->m_liveLRUIndex = queueIndex;
#endif
if (m_liveResources.size() <= queueIndex)
m_liveResources.resize(queueIndex + 1);
return &m_liveResources[queueIndex];
}
void Cache::removeFromLiveResourcesList(CachedResource* resource)
{
if (resource->liveAccessCount() == 0)
return;
#ifndef NDEBUG
unsigned oldListIndex = resource->m_liveLRUIndex;
#endif
LRUList* list = liveLRUListFor(resource);
#ifndef NDEBUG
ASSERT(resource->m_liveLRUIndex == oldListIndex);
bool found = false;
for (CachedResource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
if (current == resource) {
found = true;
break;
}
}
ASSERT(found);
#endif
CachedResource* next = resource->m_nextInLiveResourcesList;
CachedResource* prev = resource->m_prevInLiveResourcesList;
if (next == 0 && prev == 0 && list->m_head != resource)
return;
resource->m_nextInLiveResourcesList = 0;
resource->m_prevInLiveResourcesList = 0;
if (next)
next->m_prevInLiveResourcesList = prev;
else if (list->m_tail == resource)
list->m_tail = prev;
if (prev)
prev->m_nextInLiveResourcesList = next;
else if (list->m_head == resource)
list->m_head = next;
}
void Cache::insertInLiveResourcesList(CachedResource* resource)
{
ASSERT(!resource->m_nextInLiveResourcesList && !resource->m_prevInLiveResourcesList);
LRUList* list = liveLRUListFor(resource);
resource->m_nextInLiveResourcesList = list->m_head;
if (list->m_head)
list->m_head->m_prevInLiveResourcesList = resource;
list->m_head = resource;
if (!resource->m_nextInLiveResourcesList)
list->m_tail = resource;
#ifndef NDEBUG
list = liveLRUListFor(resource);
bool found = false;
for (CachedResource* current = list->m_head; current; current = current->m_nextInLiveResourcesList) {
if (current == resource) {
found = true;
break;
}
}
ASSERT(found);
#endif
}
void Cache::addToLiveResourcesSize(CachedResource* resource)
{
m_liveResourcesSize += resource->size();
m_liveDecodedSize += resource->decodedSize();
}
void Cache::removeFromLiveResourcesSize(CachedResource* resource)
{
m_liveResourcesSize -= resource->size();
m_liveDecodedSize -= resource->decodedSize();
}
void Cache::adjustSize(bool live, int delta, int decodedDelta)
{
ASSERT(delta >= 0 || ((int)m_currentSize + delta >= 0));
m_currentSize += delta;
m_currentDecodedSize += decodedDelta;
if (live) {
ASSERT(delta >= 0 || ((int)m_liveResourcesSize + delta >= 0));
m_liveResourcesSize += delta;
m_liveDecodedSize += decodedDelta;
}
}
Cache::Statistics Cache::getStatistics()
{
Statistics stats;
CachedResourceMap::iterator e = m_resources.end();
for (CachedResourceMap::iterator i = m_resources.begin(); i != e; ++i) {
CachedResource *o = i->second;
switch (o->type()) {
case CachedResource::ImageResource:
stats.images.count++;
stats.images.size += o->size();
break;
case CachedResource::CSSStyleSheet:
stats.cssStyleSheets.count++;
stats.cssStyleSheets.size += o->size();
break;
case CachedResource::Script:
stats.scripts.count++;
stats.scripts.size += o->size();
break;
#ifdef KHTML_XSLT
case CachedResource::XSLStyleSheet:
stats.xslStyleSheets.count++;
stats.xslStyleSheets.size += o->size();
break;
#endif
#ifndef KHTML_NO_XBL
case CachedResource::XBL:
stats.xblDocs.count++;
stats.xblDocs.size += o->size();
break;
#endif
default:
break;
}
}
return stats;
}
void Cache::setDisabled(bool disabled)
{
m_disabled = disabled;
if (!m_disabled)
return;
for (;;) {
CachedResourceMap::iterator i = m_resources.begin();
if (i == m_resources.end())
break;
remove(i->second);
}
}
}