NetworkCacheSpeculativeLoad.cpp [plain text]
#include "config.h"
#if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION) || ENABLE(NETWORK_CACHE_STALE_WHILE_REVALIDATE)
#include "NetworkCacheSpeculativeLoad.h"
#include "Logging.h"
#include "NetworkCache.h"
#include "NetworkLoad.h"
#include "NetworkProcess.h"
#include "NetworkSession.h"
#include <WebCore/NetworkStorageSession.h>
#include <pal/SessionID.h>
#include <wtf/RunLoop.h>
namespace WebKit {
namespace NetworkCache {
using namespace WebCore;
SpeculativeLoad::SpeculativeLoad(Cache& cache, const GlobalFrameID& globalFrameID, const ResourceRequest& request, std::unique_ptr<NetworkCache::Entry> cacheEntryForValidation, Optional<NavigatingToAppBoundDomain> isNavigatingToAppBoundDomain, RevalidationCompletionHandler&& completionHandler)
: m_cache(cache)
, m_completionHandler(WTFMove(completionHandler))
, m_originalRequest(request)
, m_bufferedDataForCache(SharedBuffer::create())
, m_cacheEntry(WTFMove(cacheEntryForValidation))
{
ASSERT(!m_cacheEntry || m_cacheEntry->needsValidation());
auto* networkSession = m_cache->networkProcess().networkSession(m_cache->sessionID());
if (!networkSession) {
RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler)]() mutable {
completionHandler(nullptr);
});
return;
}
NetworkLoadParameters parameters;
parameters.webPageProxyID = globalFrameID.webPageProxyID;
parameters.webPageID = globalFrameID.webPageID;
parameters.webFrameID = globalFrameID.frameID;
parameters.storedCredentialsPolicy = StoredCredentialsPolicy::Use;
parameters.contentSniffingPolicy = ContentSniffingPolicy::DoNotSniffContent;
parameters.contentEncodingSniffingPolicy = ContentEncodingSniffingPolicy::Sniff;
parameters.request = m_originalRequest;
parameters.isNavigatingToAppBoundDomain = isNavigatingToAppBoundDomain;
m_networkLoad = makeUnique<NetworkLoad>(*this, nullptr, WTFMove(parameters), *networkSession);
m_networkLoad->start();
}
SpeculativeLoad::~SpeculativeLoad()
{
ASSERT(!m_networkLoad);
}
void SpeculativeLoad::cancel()
{
if (!m_networkLoad)
return;
m_networkLoad->cancel();
m_networkLoad = nullptr;
m_completionHandler(nullptr);
}
void SpeculativeLoad::willSendRedirectedRequest(ResourceRequest&& request, ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
{
LOG(NetworkCacheSpeculativePreloading, "Speculative redirect %s -> %s", request.url().string().utf8().data(), redirectRequest.url().string().utf8().data());
Optional<Seconds> maxAgeCap;
#if ENABLE(RESOURCE_LOAD_STATISTICS)
if (auto* networkStorageSession = m_cache->networkProcess().storageSession(m_cache->sessionID()))
maxAgeCap = networkStorageSession->maxAgeCacheCap(request);
#endif
m_cacheEntry = m_cache->storeRedirect(request, redirectResponse, redirectRequest, maxAgeCap);
if (!m_cacheEntry)
m_cacheEntry = m_cache->makeRedirectEntry(request, redirectResponse, redirectRequest);
didComplete();
}
void SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse, ResponseCompletionHandler&& completionHandler)
{
m_response = receivedResponse;
if (m_response.isMultipart())
m_bufferedDataForCache = nullptr;
bool validationSucceeded = m_response.httpStatusCode() == 304; if (validationSucceeded && m_cacheEntry)
m_cacheEntry = m_cache->update(m_originalRequest, *m_cacheEntry, m_response);
else
m_cacheEntry = nullptr;
completionHandler(PolicyAction::Use);
}
void SpeculativeLoad::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
{
ASSERT(!m_cacheEntry);
if (m_bufferedDataForCache) {
const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize)
m_bufferedDataForCache->append(buffer.get());
else
m_bufferedDataForCache = nullptr;
}
}
void SpeculativeLoad::didFinishLoading(const WebCore::NetworkLoadMetrics&)
{
if (m_didComplete)
return;
if (!m_cacheEntry && m_bufferedDataForCache) {
m_cacheEntry = m_cache->store(m_originalRequest, m_response, m_bufferedDataForCache.copyRef(), [](auto& mappedBody) { });
if (!m_cacheEntry && isStatusCodeCacheableByDefault(m_response.httpStatusCode()))
m_cacheEntry = m_cache->makeEntry(m_originalRequest, m_response, WTFMove(m_bufferedDataForCache));
}
didComplete();
}
void SpeculativeLoad::didFailLoading(const ResourceError&)
{
if (m_didComplete)
return;
m_cacheEntry = nullptr;
didComplete();
}
void SpeculativeLoad::didComplete()
{
RELEASE_ASSERT(RunLoop::isMain());
if (m_didComplete)
return;
m_didComplete = true;
m_networkLoad = nullptr;
if (m_cacheEntry)
m_cacheEntry->setNeedsValidation(false);
m_completionHandler(WTFMove(m_cacheEntry));
}
#if !LOG_DISABLED
static void dumpHTTPHeadersDiff(const HTTPHeaderMap& headersA, const HTTPHeaderMap& headersB)
{
auto aEnd = headersA.end();
for (auto it = headersA.begin(); it != aEnd; ++it) {
String valueB = headersB.get(it->key);
if (valueB.isNull())
LOG(NetworkCacheSpeculativePreloading, "* '%s' HTTP header is only in first request (value: %s)", it->key.utf8().data(), it->value.utf8().data());
else if (it->value != valueB)
LOG(NetworkCacheSpeculativePreloading, "* '%s' HTTP header differs in both requests: %s != %s", it->key.utf8().data(), it->value.utf8().data(), valueB.utf8().data());
}
auto bEnd = headersB.end();
for (auto it = headersB.begin(); it != bEnd; ++it) {
if (!headersA.contains(it->key))
LOG(NetworkCacheSpeculativePreloading, "* '%s' HTTP header is only in second request (value: %s)", it->key.utf8().data(), it->value.utf8().data());
}
}
#endif
bool requestsHeadersMatch(const ResourceRequest& speculativeValidationRequest, const ResourceRequest& actualRequest)
{
ASSERT(!actualRequest.isConditional());
ResourceRequest speculativeRequest = speculativeValidationRequest;
speculativeRequest.makeUnconditional();
if (speculativeRequest.httpHeaderFields() != actualRequest.httpHeaderFields()) {
LOG(NetworkCacheSpeculativePreloading, "Cannot reuse speculatively validated entry because HTTP headers used for validation do not match");
#if !LOG_DISABLED
dumpHTTPHeadersDiff(speculativeRequest.httpHeaderFields(), actualRequest.httpHeaderFields());
#endif
return false;
}
return true;
}
} }
#endif // ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION) || ENABLE(NETWORK_CACHE_STALE_WHILE_REVALIDATE)