NetworkCacheSpeculativeLoadManager.h [plain text]
#ifndef NetworkCacheSpeculativeLoadManager_h
#define NetworkCacheSpeculativeLoadManager_h
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
#include "NetworkCache.h"
#include "NetworkCacheStorage.h"
#include <WebCore/ResourceRequest.h>
#include <wtf/HashMap.h>
#include <wtf/Vector.h>
namespace WebKit {
namespace NetworkCache {
class Entry;
class SpeculativeLoad;
class SubresourceInfo;
class SubresourcesEntry;
class SpeculativeLoadManager {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit SpeculativeLoadManager(Storage&);
~SpeculativeLoadManager();
void registerLoad(const GlobalFrameID&, const WebCore::ResourceRequest&, const Key& resourceKey);
typedef std::function<void (std::unique_ptr<Entry>)> RetrieveCompletionHandler;
bool retrieve(const GlobalFrameID&, const Key& storageKey, const WebCore::ResourceRequest&, RetrieveCompletionHandler&&);
private:
class PreloadedEntry;
void addPreloadedEntry(std::unique_ptr<Entry>, const GlobalFrameID&, std::optional<WebCore::ResourceRequest>&& revalidationRequest = std::nullopt);
void preloadEntry(const Key&, const SubresourceInfo&, const GlobalFrameID&);
void retrieveEntryFromStorage(const Key&, RetrieveCompletionHandler&&);
void revalidateEntry(std::unique_ptr<Entry>, const SubresourceInfo&, const GlobalFrameID&);
bool satisfyPendingRequests(const Key&, Entry*);
void retrieveSubresourcesEntry(const Key& storageKey, std::function<void (std::unique_ptr<SubresourcesEntry>)>&&);
void startSpeculativeRevalidation(const GlobalFrameID&, SubresourcesEntry&);
static bool canUsePreloadedEntry(const PreloadedEntry&, const WebCore::ResourceRequest& actualRequest);
static bool canUsePendingPreload(const SpeculativeLoad&, const WebCore::ResourceRequest& actualRequest);
Storage& m_storage;
class PendingFrameLoad;
HashMap<GlobalFrameID, RefPtr<PendingFrameLoad>> m_pendingFrameLoads;
HashMap<Key, std::unique_ptr<SpeculativeLoad>> m_pendingPreloads;
HashMap<Key, std::unique_ptr<Vector<RetrieveCompletionHandler>>> m_pendingRetrieveRequests;
HashMap<Key, std::unique_ptr<PreloadedEntry>> m_preloadedEntries;
class ExpiringEntry;
HashMap<Key, std::unique_ptr<ExpiringEntry>> m_notPreloadedEntries; };
}
}
#endif // ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
#endif // NetworkCacheSpeculativeLoadManager_h