diff options
author | Upstream <upstream-import@none> | 1970-01-12 13:46:40 +0000 |
---|---|---|
committer | Upstream <upstream-import@none> | 1970-01-12 13:46:40 +0000 |
commit | d8543bb6618c17b12da906afa77d216f58cf4058 (patch) | |
tree | c58dc05ed86825bd0ef8d305d58c8205106b540f /WebCore/loader/Cache.h | |
download | external_webkit-d8543bb6618c17b12da906afa77d216f58cf4058.zip external_webkit-d8543bb6618c17b12da906afa77d216f58cf4058.tar.gz external_webkit-d8543bb6618c17b12da906afa77d216f58cf4058.tar.bz2 |
external/webkit r30707
Diffstat (limited to 'WebCore/loader/Cache.h')
-rw-r--r-- | WebCore/loader/Cache.h | 194 |
1 files changed, 194 insertions, 0 deletions
diff --git a/WebCore/loader/Cache.h b/WebCore/loader/Cache.h new file mode 100644 index 0000000..7e43cff --- /dev/null +++ b/WebCore/loader/Cache.h @@ -0,0 +1,194 @@ +/* + This file is part of the KDE libraries + + Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de) + Copyright (C) 2001 Dirk Mueller <mueller@kde.org> + Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. + + This class provides all functionality needed for loading images, style sheets and html + pages from the web. It has a memory cache for these objects. +*/ + +#ifndef Cache_h +#define Cache_h + +#include "CachePolicy.h" +#include "CachedResource.h" +#include "PlatformString.h" +#include "StringHash.h" +#include "loader.h" +#include <wtf/HashMap.h> +#include <wtf/HashSet.h> +#include <wtf/Noncopyable.h> +#include <wtf/Vector.h> + +namespace WebCore { + +class CachedResource; +class DocLoader; +class KURL; + +// This cache holds subresources used by Web pages: images, scripts, stylesheets, etc. + +// The cache keeps a flexible but bounded window of dead resources that grows/shrinks +// depending on the live resource load. Here's an example of cache growth over time, +// with a min dead resource capacity of 25% and a max dead resource capacity of 50%: + +// |-----| Dead: - +// |----------| Live: + +// --|----------| Cache boundary: | (objects outside this mark have been evicted) +// --|----------++++++++++| +// -------|-----+++++++++++++++| +// -------|-----+++++++++++++++|+++++ + +class Cache : Noncopyable { +public: + friend Cache* cache(); + + typedef HashMap<String, CachedResource*> CachedResourceMap; + + struct LRUList { + CachedResource* m_head; + CachedResource* m_tail; + LRUList() : m_head(0), m_tail(0) { } + }; + + struct TypeStatistic { + int count; + int size; + int liveSize; + int decodedSize; + TypeStatistic() : count(0), size(0), liveSize(0), decodedSize(0) { } + }; + + struct Statistics { + TypeStatistic images; + TypeStatistic cssStyleSheets; + TypeStatistic scripts; +#if ENABLE(XSLT) + TypeStatistic xslStyleSheets; +#endif +#if ENABLE(XBL) + TypeStatistic xblDocs; +#endif + TypeStatistic fonts; + }; + + // The loader that fetches resources. + Loader* loader() { return &m_loader; } + + // Request resources from the cache. A load will be initiated and a cache object created if the object is not + // found in the cache. + CachedResource* requestResource(DocLoader*, CachedResource::Type, const KURL& url, const String* charset = 0, bool skipCanLoadCheck = false, bool sendResourceLoadCallbacks = true); + + // Sets the cache's memory capacities, in bytes. These will hold only approximately, + // since the decoded cost of resources like scripts and stylesheets is not known. + // - minDeadBytes: The maximum number of bytes that dead resources should consume when the cache is under pressure. + // - maxDeadBytes: The maximum number of bytes that dead resources should consume when the cache is not under pressure. + // - totalBytes: The maximum number of bytes that the cache should consume overall. + void setCapacities(unsigned minDeadBytes, unsigned maxDeadBytes, unsigned totalBytes); + + // Turn the cache on and off. Disabling the cache will remove all resources from the cache. They may + // still live on if they are referenced by some Web page though. + void setDisabled(bool); + bool disabled() const { return m_disabled; } + + void setPruneEnabled(bool enabled) { m_pruneEnabled = enabled; } + void prune() + { + if (m_liveSize + m_deadSize <= m_capacity && m_deadSize <= m_maxDeadCapacity) // Fast path. + return; + + pruneDeadResources(); // Prune dead first, in case it was "borrowing" capacity from live. + pruneLiveResources(); + } + + // Remove an existing cache entry from both the resource map and from the LRU list. + void remove(CachedResource*); + + void addDocLoader(DocLoader*); + void removeDocLoader(DocLoader*); + + CachedResource* resourceForURL(const String&); + + // Calls to put the cached resource into and out of LRU lists. + void insertInLRUList(CachedResource*); + void removeFromLRUList(CachedResource*); + + // Called to adjust the cache totals when a resource changes size. + void adjustSize(bool live, int delta); + + // Track decoded resources that are in the cache and referenced by a Web page. + void insertInLiveDecodedResourcesList(CachedResource*); + void removeFromLiveDecodedResourcesList(CachedResource*); + + void addToLiveResourcesSize(CachedResource*); + void removeFromLiveResourcesSize(CachedResource*); + + // Function to collect cache statistics for the caches window in the Safari Debug menu. + Statistics getStatistics(); + +private: + Cache(); + ~Cache(); // Not implemented to make sure nobody accidentally calls delete -- WebCore does not delete singletons. + + LRUList* lruListFor(CachedResource*); + void resourceAccessed(CachedResource*); +#ifndef NDEBUG + void dumpLRULists(bool includeLive) const; +#endif + + unsigned liveCapacity() const; + unsigned deadCapacity() const; + + void pruneDeadResources(); // Flush decoded and encoded data from resources not referenced by Web pages. + void pruneLiveResources(); // Flush decoded data from resources still referenced by Web pages. + + // Member variables. + HashSet<DocLoader*> m_docLoaders; + Loader m_loader; + + bool m_disabled; // Whether or not the cache is enabled. + bool m_pruneEnabled; + + unsigned m_capacity; + unsigned m_minDeadCapacity; + unsigned m_maxDeadCapacity; + + unsigned m_liveSize; // The number of bytes currently consumed by "live" resources in the cache. + unsigned m_deadSize; // The number of bytes currently consumed by "dead" resources in the cache. + + // Size-adjusted and popularity-aware LRU list collection for cache objects. This collection can hold + // more resources than the cached resource map, since it can also hold "stale" muiltiple versions of objects that are + // waiting to die when the clients referencing them go away. + Vector<LRUList, 32> m_allResources; + + // List just for live resources with decoded data. Access to this list is based off of painting the resource. + LRUList m_liveDecodedResources; + + // A URL-based map of all resources that are in the cache (including the freshest version of objects that are currently being + // referenced by a Web page). + HashMap<String, CachedResource*> m_resources; +}; + +// Function to obtain the global cache. +Cache* cache(); + +} + +#endif |