#include "config.h"
#include "PageCache.h"
#include "Cache.h"
#include "CachedPage.h"
#include "FrameLoader.h"
#include "HistoryItem.h"
#include "Logging.h"
#include "SystemTime.h"
#include <wtf/CurrentTime.h>
using namespace std;
namespace WebCore {
static const double autoreleaseInterval = 3;
PageCache* pageCache()
{
static PageCache* staticPageCache = new PageCache;
return staticPageCache;
}
PageCache::PageCache()
: m_capacity(0)
, m_size(0)
, m_head(0)
, m_tail(0)
, m_autoreleaseTimer(this, &PageCache::releaseAutoreleasedPagesNowOrReschedule)
{
}
void PageCache::setCapacity(int capacity)
{
ASSERT(capacity >= 0);
m_capacity = max(capacity, 0);
prune();
}
int PageCache::frameCount() const
{
int frameCount = 0;
for (HistoryItem* current = m_head; current; current = current->m_next) {
++frameCount;
ASSERT(current->m_cachedPage);
frameCount += current->m_cachedPage ? current->m_cachedPage->cachedMainFrame()->descendantFrameCount() : 0;
}
return frameCount;
}
int PageCache::autoreleasedPageCount() const
{
return m_autoreleaseSet.size();
}
void PageCache::add(PassRefPtr<HistoryItem> prpItem, PassRefPtr<CachedPage> cachedPage)
{
ASSERT(prpItem);
ASSERT(cachedPage);
HistoryItem* item = prpItem.releaseRef();
if (item->m_cachedPage)
remove(item);
item->m_cachedPage = cachedPage;
addToLRUList(item);
++m_size;
prune();
}
void PageCache::remove(HistoryItem* item)
{
if (!item || !item->m_cachedPage)
return;
autorelease(item->m_cachedPage.release());
removeFromLRUList(item);
--m_size;
item->deref(); }
void PageCache::prune()
{
while (m_size > m_capacity) {
ASSERT(m_tail && m_tail->m_cachedPage);
remove(m_tail);
}
}
void PageCache::addToLRUList(HistoryItem* item)
{
item->m_next = m_head;
item->m_prev = 0;
if (m_head) {
ASSERT(m_tail);
m_head->m_prev = item;
} else {
ASSERT(!m_tail);
m_tail = item;
}
m_head = item;
}
void PageCache::removeFromLRUList(HistoryItem* item)
{
if (!item->m_next) {
ASSERT(item == m_tail);
m_tail = item->m_prev;
} else {
ASSERT(item != m_tail);
item->m_next->m_prev = item->m_prev;
}
if (!item->m_prev) {
ASSERT(item == m_head);
m_head = item->m_next;
} else {
ASSERT(item != m_head);
item->m_prev->m_next = item->m_next;
}
}
void PageCache::releaseAutoreleasedPagesNowOrReschedule(Timer<PageCache>* timer)
{
double loadDelta = currentTime() - FrameLoader::timeOfLastCompletedLoad();
float userDelta = userIdleTime();
if ((userDelta < 0.5 || loadDelta < 1.25) && m_autoreleaseSet.size() < 42) {
LOG(PageCache, "WebCorePageCache: Postponing releaseAutoreleasedPagesNowOrReschedule() - %f since last load, %f since last input, %i objects pending release", loadDelta, userDelta, m_autoreleaseSet.size());
timer->startOneShot(autoreleaseInterval);
return;
}
LOG(PageCache, "WebCorePageCache: Releasing page caches - %f seconds since last load, %f since last input, %i objects pending release", loadDelta, userDelta, m_autoreleaseSet.size());
releaseAutoreleasedPagesNow();
}
void PageCache::releaseAutoreleasedPagesNow()
{
m_autoreleaseTimer.stop();
cache()->setPruneEnabled(false);
CachedPageSet tmp;
tmp.swap(m_autoreleaseSet);
CachedPageSet::iterator end = tmp.end();
for (CachedPageSet::iterator it = tmp.begin(); it != end; ++it)
(*it)->destroy();
cache()->setPruneEnabled(true);
cache()->prune();
}
void PageCache::autorelease(PassRefPtr<CachedPage> page)
{
ASSERT(page);
ASSERT(!m_autoreleaseSet.contains(page.get()));
m_autoreleaseSet.add(page);
if (!m_autoreleaseTimer.isActive())
m_autoreleaseTimer.startOneShot(autoreleaseInterval);
}
}