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 CachedFont;
class CachedImage;
class CachedResourceRequest;
class CachedScript;
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();
CachedImage* requestImage(const String& url);
CachedCSSStyleSheet* requestCSSStyleSheet(const String& url, const String& charset, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved);
CachedCSSStyleSheet* requestUserCSSStyleSheet(const String& url, const String& charset);
CachedScript* requestScript(const String& url, const String& charset);
CachedFont* requestFont(const String& url);
#if ENABLE(XSLT)
CachedXSLStyleSheet* requestXSLStyleSheet(const String& url);
#endif
#if ENABLE(LINK_PREFETCH)
CachedResource* requestLinkResource(const String &url, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved);
#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 load(CachedResource*, bool incremental = false, SecurityCheckPolicy = DoSecurityCheck, bool sendResourceLoadCallbacks = true);
void loadFinishing() { m_loadFinishing = true; }
void loadDone(CachedResourceRequest*);
void cancelRequests();
void incrementRequestCount(const CachedResource*);
void decrementRequestCount(const CachedResource*);
int requestCount();
void clearPreloads();
void clearPendingPreloads();
void preload(CachedResource::Type, const String& url, const String& charset, bool referencedFromBody);
void checkForPendingPreloads();
void printPreloadStats();
bool canRequest(CachedResource::Type, const KURL&, bool forPreload = false);
private:
CachedResource* requestResource(CachedResource::Type, const String& url, const String& charset, ResourceLoadPriority priority = ResourceLoadPriorityUnresolved, bool isPreload = false);
CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority priority);
CachedResource* loadResource(CachedResource::Type, const KURL&, const String& charset, ResourceLoadPriority priority);
void requestPreload(CachedResource::Type, const String& url, const String& charset);
enum RevalidationPolicy { Use, Revalidate, Reload, Load };
RevalidationPolicy determineRevalidationPolicy(CachedResource::Type, bool forPreload, CachedResource* existingResource) const;
void notifyLoadedFromMemoryCache(CachedResource*);
bool checkInsecureContent(CachedResource::Type, const KURL&) const;
void loadDoneActionTimerFired(Timer<CachedResourceLoader>*);
void performPostLoadActions();
HashSet<String> m_validatedURLs;
mutable DocumentResourceMap m_documentResources;
Document* m_document;
typedef HashSet<RefPtr<CachedResourceRequest> > RequestSet;
RequestSet m_requests;
int m_requestCount;
OwnPtr<ListHashSet<CachedResource*> > m_preloads;
struct PendingPreload {
CachedResource::Type m_type;
String m_url;
String m_charset;
};
Deque<PendingPreload> m_pendingPreloads;
Timer<CachedResourceLoader> m_loadDoneActionTimer;
bool m_autoLoadImages : 1;
bool m_loadFinishing : 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