#pragma once
#include "NetworkCacheEntry.h"
#include "NetworkCacheStorage.h"
#include "ShareableResource.h"
#include <WebCore/ResourceResponse.h>
#include <wtf/Function.h>
#include <wtf/OptionSet.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class LowPowerModeNotifier;
class ResourceRequest;
class SharedBuffer;
class URL;
}
namespace WebKit {
namespace NetworkCache {
class Cache;
class SpeculativeLoadManager;
class Statistics;
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 : public RefCounted<Cache> {
public:
enum class Option {
EfficacyLogging = 1 << 0,
TestingMode = 1 << 1,
RegisterNotify = 1 << 2,
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
SpeculativeRevalidation = 1 << 3,
#endif
};
static RefPtr<Cache> open(const String& cachePath, OptionSet<Option>);
void setCapacity(size_t);
struct RetrieveInfo {
MonotonicTime startTime;
MonotonicTime completionTime;
unsigned priority;
Storage::Timings storageTimings;
bool wasSpeculativeLoad { false };
WTF_MAKE_FAST_ALLOCATED;
};
using RetrieveCompletionHandler = Function<void (std::unique_ptr<Entry>, const RetrieveInfo&)>;
void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, RetrieveCompletionHandler&&);
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 remove(const Vector<Key>&, Function<void ()>&&);
void clear();
void clear(WallTime modifiedSince, Function<void ()>&& completionHandler);
void retrieveData(const DataKey&, Function<void (const uint8_t* data, size_t size)>);
void storeData(const DataKey&, const uint8_t* data, size_t);
std::unique_ptr<Entry> makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&);
std::unique_ptr<Entry> makeRedirectEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
void dumpContentsToFile();
String recordsPath() const;
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
SpeculativeLoadManager* speculativeLoadManager() { return m_speculativeLoadManager.get(); }
#endif
~Cache();
private:
Cache(Ref<Storage>&&, OptionSet<Option> options);
Key makeCacheKey(const WebCore::ResourceRequest&);
static void completeRetrieve(RetrieveCompletionHandler&&, std::unique_ptr<Entry>, RetrieveInfo&);
String dumpFilePath() const;
void deleteDumpFile();
Ref<Storage> m_storage;
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
std::unique_ptr<WebCore::LowPowerModeNotifier> m_lowPowerModeNotifier;
std::unique_ptr<SpeculativeLoadManager> m_speculativeLoadManager;
#endif
std::unique_ptr<Statistics> m_statistics;
unsigned m_traverseCount { 0 };
};
}
}