ApplicationCacheHost.h [plain text]
#ifndef ApplicationCacheHost_h
#define ApplicationCacheHost_h
#include "PlatformExportMacros.h"
#include "URL.h"
#include <wtf/Deque.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
namespace WebCore {
class DOMApplicationCache;
class DocumentLoader;
class Frame;
class ResourceError;
class ResourceLoader;
class ResourceRequest;
class ResourceResponse;
class SharedBuffer;
class SubstituteData;
class ApplicationCache;
class ApplicationCacheGroup;
class ApplicationCacheResource;
class ApplicationCacheStorage;
class ApplicationCacheHost {
WTF_MAKE_NONCOPYABLE(ApplicationCacheHost); WTF_MAKE_FAST_ALLOCATED;
public:
enum Status {
UNCACHED = 0,
IDLE = 1,
CHECKING = 2,
DOWNLOADING = 3,
UPDATEREADY = 4,
OBSOLETE = 5
};
enum EventID {
CHECKING_EVENT = 0,
ERROR_EVENT,
NOUPDATE_EVENT,
DOWNLOADING_EVENT,
PROGRESS_EVENT,
UPDATEREADY_EVENT,
CACHED_EVENT,
OBSOLETE_EVENT };
struct CacheInfo {
CacheInfo(const URL& manifest, double creationTime, double updateTime, long long size)
: m_manifest(manifest)
, m_creationTime(creationTime)
, m_updateTime(updateTime)
, m_size(size) { }
URL m_manifest;
double m_creationTime;
double m_updateTime;
long long m_size;
};
struct ResourceInfo {
ResourceInfo(const URL& resource, bool isMaster, bool isManifest, bool isFallback, bool isForeign, bool isExplicit, long long size)
: m_resource(resource)
, m_isMaster(isMaster)
, m_isManifest(isManifest)
, m_isFallback(isFallback)
, m_isForeign(isForeign)
, m_isExplicit(isExplicit)
, m_size(size) { }
URL m_resource;
bool m_isMaster;
bool m_isManifest;
bool m_isFallback;
bool m_isForeign;
bool m_isExplicit;
long long m_size;
};
typedef Vector<ResourceInfo> ResourceInfoList;
explicit ApplicationCacheHost(DocumentLoader&);
~ApplicationCacheHost();
static URL createFileURL(const String&);
void selectCacheWithoutManifest();
void selectCacheWithManifest(const URL& manifestURL);
void maybeLoadMainResource(ResourceRequest&, SubstituteData&);
void maybeLoadMainResourceForRedirect(ResourceRequest&, SubstituteData&);
bool maybeLoadFallbackForMainResponse(const ResourceRequest&, const ResourceResponse&);
void mainResourceDataReceived(const char* data, int length, long long encodedDataLength, bool allAtOnce);
void finishedLoadingMainResource();
void failedLoadingMainResource();
WEBCORE_EXPORT bool maybeLoadResource(ResourceLoader&, const ResourceRequest&, const URL& originalURL);
WEBCORE_EXPORT bool maybeLoadFallbackForRedirect(ResourceLoader*, ResourceRequest&, const ResourceResponse&);
WEBCORE_EXPORT bool maybeLoadFallbackForResponse(ResourceLoader*, const ResourceResponse&);
WEBCORE_EXPORT bool maybeLoadFallbackForError(ResourceLoader*, const ResourceError&);
bool maybeLoadSynchronously(ResourceRequest&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>&);
void maybeLoadFallbackSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>&);
bool canCacheInPageCache();
Status status() const;
bool update();
bool swapCache();
void abort();
void setDOMApplicationCache(DOMApplicationCache*);
void notifyDOMApplicationCache(EventID, int progressTotal, int progressDone);
void stopLoadingInFrame(Frame*);
void stopDeferringEvents();
void fillResourceList(ResourceInfoList*);
CacheInfo applicationCacheInfo();
bool shouldLoadResourceFromApplicationCache(const ResourceRequest&, ApplicationCacheResource*&);
bool getApplicationCacheFallbackResource(const ResourceRequest&, ApplicationCacheResource*&, ApplicationCache* = nullptr);
private:
bool isApplicationCacheEnabled();
bool isApplicationCacheBlockedForRequest(const ResourceRequest&);
struct DeferredEvent {
EventID eventID;
int progressTotal;
int progressDone;
DeferredEvent(EventID id, int total, int done) : eventID(id), progressTotal(total), progressDone(done) { }
};
DOMApplicationCache* m_domApplicationCache;
DocumentLoader& m_documentLoader;
bool m_defersEvents; Vector<DeferredEvent> m_deferredEvents;
void dispatchDOMEvent(EventID, int progressTotal, int progressDone);
friend class ApplicationCacheGroup;
friend class ApplicationCacheStorage;
bool scheduleLoadFallbackResourceFromApplicationCache(ResourceLoader*, ApplicationCache* = nullptr);
void setCandidateApplicationCacheGroup(ApplicationCacheGroup* group);
ApplicationCacheGroup* candidateApplicationCacheGroup() const { return m_candidateApplicationCacheGroup; }
void setApplicationCache(PassRefPtr<ApplicationCache> applicationCache);
ApplicationCache* applicationCache() const { return m_applicationCache.get(); }
ApplicationCache* mainResourceApplicationCache() const { return m_mainResourceApplicationCache.get(); }
bool maybeLoadFallbackForMainError(const ResourceRequest&, const ResourceError&);
RefPtr<ApplicationCache> m_applicationCache;
ApplicationCacheGroup* m_candidateApplicationCacheGroup;
RefPtr<ApplicationCache> m_mainResourceApplicationCache;
};
}
#endif // ApplicationCacheHost_h