#ifndef NetworkCache_h
#define NetworkCache_h
#if ENABLE(NETWORK_CACHE)
#include "NetworkCacheEntry.h"
#include "NetworkCacheStorage.h"
#include "ShareableResource.h"
#include <WebCore/ResourceResponse.h>
#include <wtf/Function.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class ResourceRequest;
class SharedBuffer;
class URL;
}
namespace WebKit {
namespace NetworkCache {
class Cache;
class SpeculativeLoadManager;
class Statistics;
Cache& singleton();
struct MappedBody {
#if ENABLE(SHAREABLE_RESOURCE)
RefPtr<ShareableResource> shareableResource;
ShareableResource::Handle shareableResourceHandle;
#endif
};
enum class RetrieveDecision {
Yes,
NoDueToHTTPMethod,
NoDueToConditionalRequest,
NoDueToReloadIgnoringCache,
NoDueToStreamingMedia,
};
enum class StoreDecision {
Yes,
NoDueToProtocol,
NoDueToHTTPMethod,
NoDueToAttachmentResponse, NoDueToNoStoreResponse,
NoDueToHTTPStatusCode,
NoDueToNoStoreRequest,
NoDueToUnlikelyToReuse,
NoDueToStreamingMedia,
};
enum class UseDecision {
Use,
Validate,
NoDueToVaryingHeaderMismatch,
NoDueToMissingValidatorFields,
NoDueToDecodeFailure,
NoDueToExpiredRedirect,
};
using GlobalFrameID = std::pair<uint64_t , uint64_t >;
class Cache {
WTF_MAKE_NONCOPYABLE(Cache);
friend class WTF::NeverDestroyed<Cache>;
public:
struct Parameters {
bool enableEfficacyLogging;
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
bool enableNetworkCacheSpeculativeRevalidation;
#endif
};
bool initialize(const String& cachePath, const Parameters&);
void setCapacity(size_t);
bool isEnabled() const { return !!m_storage; }
void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, std::function<void (std::unique_ptr<Entry>)>&&);
std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void (MappedBody&)>&&);
std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);
struct TraversalEntry {
const Entry& entry;
const Storage::RecordInfo& recordInfo;
};
void traverse(Function<void (const TraversalEntry*)>&&);
void remove(const Key&);
void remove(const WebCore::ResourceRequest&);
void clear();
void clear(std::chrono::system_clock::time_point modifiedSince, std::function<void ()>&& completionHandler);
void dumpContentsToFile();
String recordsPath() const;
bool canUseSharedMemoryForBodyData() const { return m_storage && m_storage->canUseSharedMemoryForBodyData(); }
private:
Cache() = default;
~Cache() = delete;
Key makeCacheKey(const WebCore::ResourceRequest&);
String dumpFilePath() const;
void deleteDumpFile();
std::unique_ptr<Storage> m_storage;
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
std::unique_ptr<SpeculativeLoadManager> m_speculativeLoadManager;
#endif
std::unique_ptr<Statistics> m_statistics;
unsigned m_traverseCount { 0 };
};
}
}
#endif
#endif