void NetworkResourceLoader::didFinishLoading(double finishTime)
{
#if ENABLE(NETWORK_CACHE)
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTF::move(m_cacheEntryForValidation));
return;
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && !m_bufferedData->isEmpty()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
#if ENABLE(NETWORK_CACHE)
tryStoreAsCacheEntry();
#endif
cleanup();
}
void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
{
if (isSynchronous()) {
m_synchronousLoadData->response = entry->response();
sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
} else {
if (entry->response().url() != originalRequest().url()) {
// This is a cached redirect. Synthesize a minimal redirect so we get things like referer header right.
// FIXME: We should cache the actual redirects.
ResourceRequest syntheticRedirectRequest(entry->response().url());
ResourceResponse syntheticRedirectResponse(originalRequest().url(), { }, 0, { });
sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(syntheticRedirectRequest, syntheticRedirectResponse));
}
bool needsContinueDidReceiveResponseMessage = originalRequest().requester() == ResourceRequest::Requester::Main;
sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage));
#if ENABLE(SHAREABLE_RESOURCE)
if (!entry->shareableResourceHandle().isNull())
send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime()));
else {
#endif
bool shouldContinue = sendBufferMaybeAborting(*entry->buffer(), entry->buffer()->size());
if (!shouldContinue)
return;
send(Messages::WebResourceLoader::DidFinishResourceLoad(currentTime()));
#if ENABLE(SHAREABLE_RESOURCE)
}
#endif
}
cleanup();
}
void NetworkResourceLoader::didFinishLoading(double finishTime)
{
RELEASE_LOG_IF_ALLOWED("didFinishLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
#if ENABLE(NETWORK_CACHE)
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTFMove(m_cacheEntryForValidation));
return;
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && !m_bufferedData->isEmpty()) {
// FIXME: Pass a real value or remove the encoded data size feature.
sendBuffer(*m_bufferedData, -1);
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
#if ENABLE(NETWORK_CACHE)
tryStoreAsCacheEntry();
#endif
cleanup();
}
void NetworkResourceLoader::sharedDidFinishLoading(double finishTime)
{
#if ENABLE(NETWORK_CACHE)
if (NetworkCache::singleton().isEnabled()) {
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTF::move(m_cacheEntryForValidation));
return;
}
bool allowStale = originalRequest().cachePolicy() >= ReturnCacheDataElseLoad;
bool hasCacheableRedirect = m_response.isHTTP() && WebCore::redirectChainAllowsReuse(m_redirectChainCacheStatus, allowStale ? WebCore::ReuseExpiredRedirection : WebCore::DoNotReuseExpiredRedirection);
if (hasCacheableRedirect && m_redirectChainCacheStatus.status == RedirectChainCacheStatus::CachedRedirection) {
// Maybe we should cache the actual redirects instead of the end result?
auto now = std::chrono::system_clock::now();
auto responseEndOfValidity = now + WebCore::computeFreshnessLifetimeForHTTPFamily(m_response, now) - WebCore::computeCurrentAge(m_response, now);
hasCacheableRedirect = responseEndOfValidity <= m_redirectChainCacheStatus.endOfValidity;
}
bool isPrivate = sessionID().isEphemeral();
if (m_bufferedDataForCache && hasCacheableRedirect && !isPrivate) {
// Keep the connection alive.
RefPtr<NetworkConnectionToWebProcess> connection(connectionToWebProcess());
RefPtr<NetworkResourceLoader> loader(this);
NetworkCache::singleton().store(originalRequest(), m_response, WTF::move(m_bufferedDataForCache), [loader, connection](NetworkCache::MappedBody& mappedBody) {
#if ENABLE(SHAREABLE_RESOURCE)
if (mappedBody.shareableResourceHandle.isNull())
return;
LOG(NetworkCache, "(NetworkProcess) sending DidCacheResource");
loader->send(Messages::NetworkProcessConnection::DidCacheResource(loader->originalRequest(), mappedBody.shareableResourceHandle, loader->sessionID()));
#endif
});
} else if (!hasCacheableRedirect) {
// Make sure we don't keep a stale entry in the cache.
NetworkCache::singleton().remove(originalRequest());
}
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && m_bufferedData->size()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
cleanup();
}
void NetworkResourceLoader::didFail(ResourceHandle* handle, const ResourceError& error)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
void NetworkResourceLoader::didFinishLoading(ResourceHandle* handle, double finishTime)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && m_bufferedData->size())
sendBuffer(m_bufferedData.get(), -1);
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
cleanup();
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
RELEASE_LOG_IF_ALLOWED("didFailLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isTimeout = %d, isCancellation = %d, errCode = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, error.isTimeout(), error.isCancellation(), error.errorCode());
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else if (auto* connection = messageSenderConnection())
connection->send(Messages::WebResourceLoader::DidFailResourceLoad(error), messageSenderDestinationID());
cleanup();
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
NETWORKRESOURCELOADER_LOG_ALWAYS("Failed loading network resource: loader = %p, pageID = %llu, frameID = %llu, isMainResource = %d, isSynchronous = %d, isTimeout = %d, isCancellation = %d, errCode = %d", this, m_parameters.webPageID, m_parameters.webFrameID, isMainResource(), isSynchronous(), error.isTimeout(), error.isCancellation(), error.errorCode());
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
{
if (isSynchronous()) {
m_synchronousLoadData->response = entry->response();
sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
} else {
bool needsContinueDidReceiveResponseMessage = isMainResource();
send(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage));
#if ENABLE(SHAREABLE_RESOURCE)
if (!entry->shareableResourceHandle().isNull())
send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime()));
else {
#endif
sendBuffer(*entry->buffer(), entry->buffer()->size());
send(Messages::WebResourceLoader::DidFinishResourceLoad(currentTime()));
#if ENABLE(SHAREABLE_RESOURCE)
}
#endif
}
cleanup();
}
