CachedResourceLoader.h [plain text]
#ifndef CachedResourceLoader_h
#define CachedResourceLoader_h
#include "CachedResource.h"
#include "CachedResourceHandle.h"
#include "CachePolicy.h"
#include "ResourceLoadPriority.h"
#include "Timer.h"
#include <wtf/Deque.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/text/StringHash.h>
namespace WebCore {
class CachedCSSStyleSheet;
class CachedSVGDocument;
class CachedFont;
class CachedImage;
class CachedRawResource;
class CachedScript;
class CachedShader;
class CachedTextTrack;
class CachedXSLStyleSheet;
class Document;
class Frame;
class ImageLoader;
class KURL;
class CachedResourceLoader {
WTF_MAKE_NONCOPYABLE(CachedResourceLoader); WTF_MAKE_FAST_ALLOCATED;
friend class ImageLoader;
friend class ResourceCacheValidationSuppressor;
public:
CachedResourceLoader(Document*);
~CachedResourceLoader();
CachedResourceHandle<CachedImage> requestImage(ResourceRequest&);
CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(ResourceRequest&, const String& charset);
CachedResourceHandle<CachedScript> requestScript(ResourceRequest&, const String& charset);
CachedResourceHandle<CachedFont> requestFont(ResourceRequest&);
CachedResourceHandle<CachedRawResource> requestRawResource(ResourceRequest&, const ResourceLoaderOptions&);
#if ENABLE(SVG)
CachedResourceHandle<CachedSVGDocument> requestSVGDocument(ResourceRequest&);
#endif
#if ENABLE(XSLT)
CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(ResourceRequest&);
#endif
#if ENABLE(LINK_PREFETCH)
CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
#endif
#if ENABLE(VIDEO_TRACK)
CachedResourceHandle<CachedTextTrack> requestTextTrack(ResourceRequest&);
#endif
#if ENABLE(CSS_SHADERS)
CachedResourceHandle<CachedShader> requestShader(ResourceRequest&);
#endif
void printAccessDeniedMessage(const KURL& url) const;
CachedResource* cachedResource(const String& url) const;
CachedResource* cachedResource(const KURL& url) const;
typedef HashMap<String, CachedResourceHandle<CachedResource> > DocumentResourceMap;
const DocumentResourceMap& allCachedResources() const { return m_documentResources; }
bool autoLoadImages() const { return m_autoLoadImages; }
void setAutoLoadImages(bool);
CachePolicy cachePolicy() const;
Frame* frame() const; Document* document() const { return m_document; }
void removeCachedResource(CachedResource*) const;
void loadDone(bool doPostLoadActionsAsynchronously = false);
void incrementRequestCount(const CachedResource*);
void decrementRequestCount(const CachedResource*);
int requestCount() const { return m_requestCount; }
bool isPreloaded(const String& urlString) const;
void clearPreloads();
void clearPendingPreloads();
void preload(CachedResource::Type, ResourceRequest&, const String& charset, bool referencedFromBody);
void checkForPendingPreloads();
void printPreloadStats();
bool canRequest(CachedResource::Type, const KURL&, bool forPreload = false);
private:
CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);
CachedResourceHandle<CachedResource> revalidateResource(CachedResource*, ResourceLoadPriority, const ResourceLoaderOptions&);
CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority, const ResourceLoaderOptions&);
void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);
enum RevalidationPolicy { Use, Revalidate, Reload, Load };
RevalidationPolicy determineRevalidationPolicy(CachedResource::Type, ResourceRequest&, bool forPreload, CachedResource* existingResource) const;
void notifyLoadedFromMemoryCache(CachedResource*);
bool checkInsecureContent(CachedResource::Type, const KURL&) const;
void garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>*);
void performPostLoadActions();
HashSet<String> m_validatedURLs;
mutable DocumentResourceMap m_documentResources;
Document* m_document;
int m_requestCount;
OwnPtr<ListHashSet<CachedResource*> > m_preloads;
struct PendingPreload {
CachedResource::Type m_type;
ResourceRequest m_request;
String m_charset;
};
Deque<PendingPreload> m_pendingPreloads;
Timer<CachedResourceLoader> m_garbageCollectDocumentResourcesTimer;
bool m_autoLoadImages : 1;
bool m_allowStaleResources : 1;
};
class ResourceCacheValidationSuppressor {
WTF_MAKE_NONCOPYABLE(ResourceCacheValidationSuppressor);
WTF_MAKE_FAST_ALLOCATED;
public:
ResourceCacheValidationSuppressor(CachedResourceLoader* loader)
: m_loader(loader)
, m_previousState(false)
{
if (m_loader) {
m_previousState = m_loader->m_allowStaleResources;
m_loader->m_allowStaleResources = true;
}
}
~ResourceCacheValidationSuppressor()
{
if (m_loader)
m_loader->m_allowStaleResources = m_previousState;
}
private:
CachedResourceLoader* m_loader;
bool m_previousState;
};
}
#endif