diff options
Diffstat (limited to 'Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp')
| -rw-r--r-- | Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp | 735 |
1 files changed, 512 insertions, 223 deletions
diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp index 60d13a338..bab56b3b4 100644 --- a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp +++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 Apple Inc. All rights reserved. + * Copyright (C) 2012-2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,393 +26,682 @@ #include "config.h" #include "NetworkResourceLoader.h" -#if ENABLE(NETWORK_PROCESS) - -#include "AsynchronousNetworkLoaderClient.h" -#include "AuthenticationManager.h" #include "DataReference.h" #include "Logging.h" #include "NetworkBlobRegistry.h" +#include "NetworkCache.h" #include "NetworkConnectionToWebProcess.h" +#include "NetworkLoad.h" #include "NetworkProcess.h" #include "NetworkProcessConnectionMessages.h" -#include "NetworkResourceLoadParameters.h" -#include "RemoteNetworkingContext.h" -#include "ShareableResource.h" -#include "SharedMemory.h" -#include "SynchronousNetworkLoaderClient.h" +#include "SessionTracker.h" #include "WebCoreArgumentCoders.h" #include "WebErrors.h" #include "WebResourceLoaderMessages.h" -#include <WebCore/NotImplemented.h> -#include <WebCore/ResourceBuffer.h> -#include <WebCore/ResourceHandle.h> -#include <wtf/MainThread.h> +#include <WebCore/BlobDataFileReference.h> +#include <WebCore/CertificateInfo.h> +#include <WebCore/DiagnosticLoggingKeys.h> +#include <WebCore/HTTPHeaderNames.h> +#include <WebCore/ProtectionSpace.h> +#include <WebCore/SharedBuffer.h> +#include <WebCore/SynchronousLoaderClient.h> +#include <wtf/CurrentTime.h> +#include <wtf/RunLoop.h> using namespace WebCore; +#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(isAlwaysOnLoggingAllowed(), Network, "%p - NetworkResourceLoader::" fmt, this, ##__VA_ARGS__) +#define RELEASE_LOG_ERROR_IF_ALLOWED(fmt, ...) RELEASE_LOG_ERROR_IF(isAlwaysOnLoggingAllowed(), Network, "%p - NetworkResourceLoader::" fmt, this, ##__VA_ARGS__) + namespace WebKit { -NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply) - : m_bytesReceived(0) - , m_handleConvertedToDownload(false) - , m_identifier(parameters.identifier) - , m_webPageID(parameters.webPageID) - , m_webFrameID(parameters.webFrameID) - , m_sessionID(parameters.sessionID) - , m_request(parameters.request) - , m_priority(parameters.priority) - , m_contentSniffingPolicy(parameters.contentSniffingPolicy) - , m_allowStoredCredentials(parameters.allowStoredCredentials) - , m_clientCredentialPolicy(parameters.clientCredentialPolicy) - , m_shouldClearReferrerOnHTTPSToHTTPRedirect(parameters.shouldClearReferrerOnHTTPSToHTTPRedirect) - , m_isLoadingMainResource(parameters.isMainResource) - , m_sandboxExtensionsAreConsumed(false) +struct NetworkResourceLoader::SynchronousLoadData { + SynchronousLoadData(RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply) + : delayedReply(WTFMove(reply)) + { + ASSERT(delayedReply); + } + ResourceRequest currentRequest; + RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> delayedReply; + ResourceResponse response; + ResourceError error; +}; + +static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const SharedBuffer* buffer) +{ + ASSERT(data.delayedReply); + ASSERT(!data.response.isNull() || !data.error.isNull()); + + Vector<char> responseBuffer; + if (buffer && buffer->size()) + responseBuffer.append(buffer->data(), buffer->size()); + + data.delayedReply->send(data.error, data.response, responseBuffer); + data.delayedReply = nullptr; +} + +NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess& connection, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& synchronousReply) + : m_parameters(parameters) , m_connection(connection) + , m_defersLoading(parameters.defersLoading) + , m_bufferingTimer(*this, &NetworkResourceLoader::bufferingTimerFired) { - // Either this loader has both a webPageID and webFrameID, or it is not allowed to ask the client for authentication credentials. + ASSERT(RunLoop::isMain()); // FIXME: This is necessary because of the existence of EmptyFrameLoaderClient in WebCore. // Once bug 116233 is resolved, this ASSERT can just be "m_webPageID && m_webFrameID" - ASSERT((m_webPageID && m_webFrameID) || m_clientCredentialPolicy == DoNotAskClientForAnyCredentials); + ASSERT((m_parameters.webPageID && m_parameters.webFrameID) || m_parameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials); - for (size_t i = 0, count = parameters.requestBodySandboxExtensions.size(); i < count; ++i) { - if (RefPtr<SandboxExtension> extension = SandboxExtension::create(parameters.requestBodySandboxExtensions[i])) - m_requestBodySandboxExtensions.append(extension); - } - -#if ENABLE(BLOB) - if (m_request.httpBody()) { - const Vector<FormDataElement>& elements = m_request.httpBody()->elements(); - for (size_t i = 0, count = elements.size(); i < count; ++i) { - if (elements[i].m_type == FormDataElement::encodedBlob) { - Vector<RefPtr<SandboxExtension>> blobElementExtensions = NetworkBlobRegistry::shared().sandboxExtensions(elements[i].m_url); - m_requestBodySandboxExtensions.appendVector(blobElementExtensions); - } + if (originalRequest().httpBody()) { + for (const auto& element : originalRequest().httpBody()->elements()) { + if (element.m_type == FormDataElement::Type::EncodedBlob) + m_fileReferences.appendVector(NetworkBlobRegistry::singleton().filesInBlob(connection, element.m_url)); } } - if (m_request.url().protocolIs("blob")) { - ASSERT(!SandboxExtension::create(parameters.resourceSandboxExtension)); - m_resourceSandboxExtensions = NetworkBlobRegistry::shared().sandboxExtensions(m_request.url()); - } else +#if !USE(NETWORK_SESSION) + if (originalRequest().url().protocolIsBlob()) { + ASSERT(!m_parameters.resourceSandboxExtension); + m_fileReferences.appendVector(NetworkBlobRegistry::singleton().filesInBlob(connection, originalRequest().url())); + } #endif - if (RefPtr<SandboxExtension> resourceSandboxExtension = SandboxExtension::create(parameters.resourceSandboxExtension)) - m_resourceSandboxExtensions.append(resourceSandboxExtension); - ASSERT(isMainThread()); - - if (reply) - m_networkLoaderClient = std::make_unique<SynchronousNetworkLoaderClient>(m_request, reply); - else - m_networkLoaderClient = std::make_unique<AsynchronousNetworkLoaderClient>(); + + if (synchronousReply) + m_synchronousLoadData = std::make_unique<SynchronousLoadData>(WTFMove(synchronousReply)); } NetworkResourceLoader::~NetworkResourceLoader() { - ASSERT(isMainThread()); - ASSERT(!m_handle); - ASSERT(!m_hostRecord); + ASSERT(RunLoop::isMain()); + ASSERT(!m_networkLoad); + ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply); } +#if ENABLE(NETWORK_CACHE) +bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const +{ + if (!NetworkCache::singleton().isEnabled()) + return false; + if (sessionID().isEphemeral()) + return false; + if (!request.url().protocolIsInHTTPFamily()) + return false; + if (originalRequest().cachePolicy() == WebCore::DoNotUseAnyCache) + return false; + + return true; +} + +bool NetworkResourceLoader::canUseCachedRedirect(const ResourceRequest& request) const +{ + if (!canUseCache(request)) + return false; + // Limit cached redirects to avoid cycles and other trouble. + // Networking layer follows over 30 redirects but caching that many seems unnecessary. + static const unsigned maximumCachedRedirectCount { 5 }; + if (m_redirectCount > maximumCachedRedirectCount) + return false; + + return true; +} +#endif + bool NetworkResourceLoader::isSynchronous() const { - return m_networkLoaderClient->isSynchronous(); + return !!m_synchronousLoadData; } void NetworkResourceLoader::start() { - ASSERT(isMainThread()); + ASSERT(RunLoop::isMain()); + + if (m_defersLoading) { + RELEASE_LOG_IF_ALLOWED("start: Loading is deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous()); + return; + } + +#if ENABLE(NETWORK_CACHE) + if (canUseCache(originalRequest())) { + RELEASE_LOG_IF_ALLOWED("start: Retrieving resource from cache (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous()); + retrieveCacheEntry(originalRequest()); + return; + } +#endif - // Explicit ref() balanced by a deref() in NetworkResourceLoader::resourceHandleStopped() - ref(); + startNetworkLoad(originalRequest()); +} - // FIXME (NetworkProcess): Set platform specific settings. - m_networkingContext = RemoteNetworkingContext::create(m_sessionID, m_shouldClearReferrerOnHTTPSToHTTPRedirect); +#if ENABLE(NETWORK_CACHE) +void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request) +{ + ASSERT(canUseCache(request)); + + RefPtr<NetworkResourceLoader> loader(this); + NetworkCache::singleton().retrieve(request, { m_parameters.webPageID, m_parameters.webFrameID }, [loader = WTFMove(loader), request](auto entry) { + if (loader->hasOneRef()) { + // The loader has been aborted and is only held alive by this lambda. + return; + } + if (!entry) { + loader->startNetworkLoad(request); + return; + } + if (entry->redirectRequest()) { + loader->dispatchWillSendRequestForCacheEntry(WTFMove(entry)); + return; + } + if (loader->m_parameters.needsCertificateInfo && !entry->response().certificateInfo()) { + loader->startNetworkLoad(request); + return; + } + if (entry->needsValidation() || request.cachePolicy() == WebCore::RefreshAnyCacheData) { + loader->validateCacheEntry(WTFMove(entry)); + return; + } + loader->didRetrieveCacheEntry(WTFMove(entry)); + }); +} +#endif + +void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request) +{ + RELEASE_LOG_IF_ALLOWED("startNetworkLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous()); consumeSandboxExtensions(); - // FIXME (NetworkProcess): Pass an actual value for defersLoading - m_handle = ResourceHandle::create(m_networkingContext.get(), m_request, this, false /* defersLoading */, m_contentSniffingPolicy == SniffContent); + if (isSynchronous() || m_parameters.maximumBufferingTime > 0ms) + m_bufferedData = SharedBuffer::create(); + +#if ENABLE(NETWORK_CACHE) + if (canUseCache(request)) + m_bufferedDataForCache = SharedBuffer::create(); +#endif + + NetworkLoadParameters parameters = m_parameters; + parameters.defersLoading = m_defersLoading; + parameters.request = request; + +#if USE(NETWORK_SESSION) + if (request.url().protocolIsBlob()) + parameters.blobFileReferences = NetworkBlobRegistry::singleton().filesInBlob(m_connection, originalRequest().url()); + + auto* networkSession = SessionTracker::networkSession(parameters.sessionID); + if (!networkSession) { + WTFLogAlways("Attempted to create a NetworkLoad with a session (id=%" PRIu64 ") that does not exist.", parameters.sessionID.sessionID()); + RELEASE_LOG_ERROR_IF_ALLOWED("startNetworkLoad: Attempted to create a NetworkLoad with a session that does not exist (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", sessionID=%" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, parameters.sessionID.sessionID()); + NetworkProcess::singleton().logDiagnosticMessage(m_parameters.webPageID, WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::invalidSessionIDKey(), WebCore::ShouldSample::No); + didFailLoading(internalError(request.url())); + return; + } + m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters), *networkSession); +#else + m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters)); +#endif + + if (m_defersLoading) { + RELEASE_LOG_IF_ALLOWED("startNetworkLoad: Created, but deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", + m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + } +} + +void NetworkResourceLoader::setDefersLoading(bool defers) +{ + if (m_defersLoading == defers) + return; + m_defersLoading = defers; + + if (defers) + RELEASE_LOG_IF_ALLOWED("setDefersLoading: Deferring resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + else + RELEASE_LOG_IF_ALLOWED("setDefersLoading: Resuming deferred resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + + if (m_networkLoad) { + m_networkLoad->setDefersLoading(defers); + return; + } + + if (!m_defersLoading) + start(); + else + RELEASE_LOG_IF_ALLOWED("setDefersLoading: defers = TRUE, but nothing to stop (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); } void NetworkResourceLoader::cleanup() { - ASSERT(isMainThread()); + ASSERT(RunLoop::isMain()); - invalidateSandboxExtensions(); + m_bufferingTimer.stop(); - if (FormData* formData = request().httpBody()) - formData->removeGeneratedFilesIfNeeded(); + invalidateSandboxExtensions(); - // Tell the scheduler about this finished loader soon so it can start more network requests. - NetworkProcess::shared().networkResourceLoadScheduler().scheduleRemoveLoader(this); + m_networkLoad = nullptr; - if (m_handle) { - // Explicit deref() balanced by a ref() in NetworkResourceLoader::start() - // This might cause the NetworkResourceLoader to be destroyed and therefore we do it last. - m_handle = 0; - deref(); - } + // This will cause NetworkResourceLoader to be destroyed and therefore we do it last. + m_connection->didCleanupResourceLoader(*this); } -void NetworkResourceLoader::didConvertHandleToDownload() +void NetworkResourceLoader::convertToDownload(DownloadID downloadID, const ResourceRequest& request, const ResourceResponse& response) { - ASSERT(m_handle); - m_handleConvertedToDownload = true; + ASSERT(m_networkLoad); + NetworkProcess::singleton().downloadManager().convertNetworkLoadToDownload(downloadID, std::exchange(m_networkLoad, nullptr), WTFMove(m_fileReferences), request, response); } void NetworkResourceLoader::abort() { - ASSERT(isMainThread()); + ASSERT(RunLoop::isMain()); - if (m_handle && !m_handleConvertedToDownload) - m_handle->cancel(); + RELEASE_LOG_IF_ALLOWED("abort: Canceling resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", + m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + + if (m_networkLoad) { +#if ENABLE(NETWORK_CACHE) + if (canUseCache(m_networkLoad->currentRequest())) { + // We might already have used data from this incomplete load. Ensure older versions don't remain in the cache after cancel. + if (!m_response.isNull()) + NetworkCache::singleton().remove(m_networkLoad->currentRequest()); + } +#endif + m_networkLoad->cancel(); + } cleanup(); } -void NetworkResourceLoader::didReceiveResponseAsync(ResourceHandle* handle, const ResourceResponse& response) +auto NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedResponse) -> ShouldContinueDidReceiveResponse { - ASSERT_UNUSED(handle, handle == m_handle); - - // FIXME (NetworkProcess): Cache the response. - if (FormData* formData = request().httpBody()) - formData->removeGeneratedFilesIfNeeded(); + RELEASE_LOG_IF_ALLOWED("didReceiveResponse: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", httpStatusCode = %d, length = %" PRId64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, receivedResponse.httpStatusCode(), receivedResponse.expectedContentLength()); + + m_response = WTFMove(receivedResponse); + + // For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling. + if (!isSynchronous() && m_response.isMultipart()) + m_bufferedData = nullptr; + + bool shouldSendDidReceiveResponse = true; +#if ENABLE(NETWORK_CACHE) + if (m_response.isMultipart()) + m_bufferedDataForCache = nullptr; + + if (m_cacheEntryForValidation) { + bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified + if (validationSucceeded) { + m_cacheEntryForValidation = NetworkCache::singleton().update(originalRequest(), { m_parameters.webPageID, m_parameters.webFrameID }, *m_cacheEntryForValidation, m_response); + // If the request was conditional then this revalidation was not triggered by the network cache and we pass the 304 response to WebCore. + if (originalRequest().isConditional()) + m_cacheEntryForValidation = nullptr; + } else + m_cacheEntryForValidation = nullptr; + } + shouldSendDidReceiveResponse = !m_cacheEntryForValidation; +#endif - m_networkLoaderClient->didReceiveResponse(this, response); + bool shouldWaitContinueDidReceiveResponse = isMainResource(); + if (shouldSendDidReceiveResponse) { + if (isSynchronous()) + m_synchronousLoadData->response = m_response; + else + send(Messages::WebResourceLoader::DidReceiveResponse(m_response, shouldWaitContinueDidReceiveResponse)); + } - // m_handle will be 0 if the request got aborted above. - if (!m_handle) - return; + // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message. + bool shouldContinueDidReceiveResponse = !shouldWaitContinueDidReceiveResponse; +#if ENABLE(NETWORK_CACHE) + shouldContinueDidReceiveResponse = shouldContinueDidReceiveResponse || m_cacheEntryForValidation; +#endif - if (!m_isLoadingMainResource) { - // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message. - m_handle->continueDidReceiveResponse(); + if (shouldContinueDidReceiveResponse) { + RELEASE_LOG_IF_ALLOWED("didReceiveResponse: Should not wait for message from WebContent process before continuing resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + return ShouldContinueDidReceiveResponse::Yes; } -} -void NetworkResourceLoader::didReceiveData(ResourceHandle*, const char* data, unsigned length, int encodedDataLength) -{ - // The NetworkProcess should never get a didReceiveData callback. - // We should always be using didReceiveBuffer. - ASSERT_NOT_REACHED(); + RELEASE_LOG_IF_ALLOWED("didReceiveResponse: Should wait for message from WebContent process before continuing resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + return ShouldContinueDidReceiveResponse::No; } -void NetworkResourceLoader::didReceiveBuffer(ResourceHandle* handle, PassRefPtr<SharedBuffer> buffer, int encodedDataLength) +void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength) { - ASSERT_UNUSED(handle, handle == m_handle); + if (!m_hasReceivedData) { + RELEASE_LOG_IF_ALLOWED("didReceiveBuffer: Started receiving data (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); + m_hasReceivedData = true; + } + +#if ENABLE(NETWORK_CACHE) + ASSERT(!m_cacheEntryForValidation); + + if (m_bufferedDataForCache) { + // Prevent memory growth in case of streaming data. + const size_t maximumCacheBufferSize = 10 * 1024 * 1024; + if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize) + m_bufferedDataForCache->append(buffer.get()); + else + m_bufferedDataForCache = nullptr; + } +#endif + // FIXME: At least on OS X Yosemite we always get -1 from the resource handle. + unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size(); - // FIXME (NetworkProcess): For the memory cache we'll also need to cache the response data here. - // Such buffering will need to be thread safe, as this callback is happening on a background thread. - m_bytesReceived += buffer->size(); - m_networkLoaderClient->didReceiveBuffer(this, buffer.get(), encodedDataLength); + if (m_bufferedData) { + m_bufferedData->append(buffer.get()); + m_bufferedDataEncodedDataLength += encodedDataLength; + startBufferingTimerIfNeeded(); + return; + } + sendBuffer(buffer, encodedDataLength); } -void NetworkResourceLoader::didFinishLoading(ResourceHandle* handle, double finishTime) +void NetworkResourceLoader::didFinishLoading(double finishTime) { - ASSERT_UNUSED(handle, handle == m_handle); + 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 - m_networkLoaderClient->didFinishLoading(this, finishTime); + 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::didFail(ResourceHandle* handle, const ResourceError& error) +void NetworkResourceLoader::didFailLoading(const ResourceError& error) { - ASSERT_UNUSED(handle, handle == m_handle); + 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()); - m_networkLoaderClient->didFail(this, error); +#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::willSendRequestAsync(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& redirectResponse) +void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, WebCore::ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse) { - ASSERT_UNUSED(handle, handle == m_handle); - - // We only expect to get the willSendRequest callback from ResourceHandle as the result of a redirect. - ASSERT(!redirectResponse.isNull()); - ASSERT(isMainThread()); - - ResourceRequest proposedRequest = request; - m_suggestedRequestForWillSendRequest = request; + ++m_redirectCount; + + if (isSynchronous()) { + ResourceRequest overridenRequest = redirectRequest; + // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests. + // This includes at least updating host records, and comparing the current request instead of the original request here. + if (!protocolHostAndPortAreEqual(originalRequest().url(), redirectRequest.url())) { + ASSERT(m_synchronousLoadData->error.isNull()); + m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError(); + m_networkLoad->clearCurrentRequest(); + overridenRequest = ResourceRequest(); + } + continueWillSendRequest(WTFMove(overridenRequest)); + return; + } + send(Messages::WebResourceLoader::WillSendRequest(redirectRequest, redirectResponse)); - m_networkLoaderClient->willSendRequest(this, proposedRequest, redirectResponse); +#if ENABLE(NETWORK_CACHE) + if (canUseCachedRedirect(request)) + NetworkCache::singleton().storeRedirect(request, redirectResponse, redirectRequest); +#else + UNUSED_PARAM(request); +#endif } -void NetworkResourceLoader::continueWillSendRequest(const ResourceRequest& newRequest) +void NetworkResourceLoader::continueWillSendRequest(ResourceRequest&& newRequest) { -#if PLATFORM(MAC) - m_suggestedRequestForWillSendRequest.updateFromDelegatePreservingOldHTTPBody(newRequest.nsURLRequest(DoNotUpdateHTTPBody)); -#elif USE(SOUP) - // FIXME: Implement ResourceRequest::updateFromDelegatePreservingOldHTTPBody. See https://bugs.webkit.org/show_bug.cgi?id=126127. - m_suggestedRequestForWillSendRequest.updateFromDelegatePreservingOldHTTPBody(newRequest); -#endif + RELEASE_LOG_IF_ALLOWED("continueWillSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); - RunLoop::main()->dispatch(bind(&NetworkResourceLoadScheduler::receivedRedirect, &NetworkProcess::shared().networkResourceLoadScheduler(), this, m_suggestedRequestForWillSendRequest.url())); + // If there is a match in the network cache, we need to reuse the original cache policy. + newRequest.setCachePolicy(originalRequest().cachePolicy()); - m_request = m_suggestedRequestForWillSendRequest; - m_suggestedRequestForWillSendRequest = ResourceRequest(); +#if ENABLE(NETWORK_CACHE) + if (m_isWaitingContinueWillSendRequestForCachedRedirect) { + m_isWaitingContinueWillSendRequestForCachedRedirect = false; + + LOG(NetworkCache, "(NetworkProcess) Retrieving cached redirect"); + + if (canUseCachedRedirect(newRequest)) + retrieveCacheEntry(newRequest); + else + startNetworkLoad(newRequest); - if (m_request.isNull()) { - m_handle->cancel(); - didFail(m_handle.get(), cancelledError(m_request)); return; } +#endif - m_handle->continueWillSendRequest(m_request); + if (m_networkLoad) + m_networkLoad->continueWillSendRequest(WTFMove(newRequest)); } void NetworkResourceLoader::continueDidReceiveResponse() { // FIXME: Remove this check once BlobResourceHandle implements didReceiveResponseAsync correctly. // Currently, it does not wait for response, so the load is likely to finish before continueDidReceiveResponse. - if (!m_handle) - return; - - m_handle->continueDidReceiveResponse(); + if (m_networkLoad) + m_networkLoad->continueDidReceiveResponse(); } -void NetworkResourceLoader::didSendData(ResourceHandle* handle, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) +void NetworkResourceLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) { - ASSERT_UNUSED(handle, handle == m_handle); - - m_networkLoaderClient->didSendData(this, bytesSent, totalBytesToBeSent); + if (!isSynchronous()) + send(Messages::WebResourceLoader::DidSendData(bytesSent, totalBytesToBeSent)); } -void NetworkResourceLoader::wasBlocked(ResourceHandle* handle) +void NetworkResourceLoader::startBufferingTimerIfNeeded() { - ASSERT_UNUSED(handle, handle == m_handle); - - didFail(handle, WebKit::blockedError(request())); + if (isSynchronous()) + return; + if (m_bufferingTimer.isActive()) + return; + m_bufferingTimer.startOneShot(m_parameters.maximumBufferingTime); } -void NetworkResourceLoader::cannotShowURL(ResourceHandle* handle) +void NetworkResourceLoader::bufferingTimerFired() { - ASSERT_UNUSED(handle, handle == m_handle); + ASSERT(m_bufferedData); + ASSERT(m_networkLoad); - didFail(handle, WebKit::cannotShowURLError(request())); + if (m_bufferedData->isEmpty()) + return; + + IPC::SharedBufferDataReference dataReference(m_bufferedData.get()); + size_t encodedLength = m_bufferedDataEncodedDataLength; + + m_bufferedData = SharedBuffer::create(); + m_bufferedDataEncodedDataLength = 0; + + send(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedLength)); } -bool NetworkResourceLoader::shouldUseCredentialStorage(ResourceHandle* handle) +void NetworkResourceLoader::sendBuffer(SharedBuffer& buffer, size_t encodedDataLength) { - ASSERT_UNUSED(handle, handle == m_handle || !m_handle); // m_handle will be 0 if called from ResourceHandle::start(). + ASSERT(!isSynchronous()); - // When the WebProcess is handling loading a client is consulted each time this shouldUseCredentialStorage question is asked. - // In NetworkProcess mode we ask the WebProcess client up front once and then reuse the cached answer. + IPC::SharedBufferDataReference dataReference(&buffer); + send(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength)); +} - // We still need this sync version, because ResourceHandle itself uses it internally, even when the delegate uses an async one. +#if ENABLE(NETWORK_CACHE) +void NetworkResourceLoader::tryStoreAsCacheEntry() +{ + if (!canUseCache(m_networkLoad->currentRequest())) + return; + if (!m_bufferedDataForCache) + return; - return m_allowStoredCredentials == AllowStoredCredentials; + NetworkCache::singleton().store(m_networkLoad->currentRequest(), m_response, WTFMove(m_bufferedDataForCache), [loader = makeRef(*this)](auto& mappedBody) mutable { +#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 + }); } -void NetworkResourceLoader::shouldUseCredentialStorageAsync(ResourceHandle* handle) +void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) { - ASSERT_UNUSED(handle, handle == m_handle); + if (isSynchronous()) { + m_synchronousLoadData->response = entry->response(); + sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer()); + cleanup(); + return; + } - handle->continueShouldUseCredentialStorage(shouldUseCredentialStorage(handle)); + bool needsContinueDidReceiveResponseMessage = isMainResource(); + send(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage)); + + if (entry->sourceStorageRecord().bodyHash && !m_parameters.derivedCachedDataTypesToRetrieve.isEmpty()) { + auto bodyHash = *entry->sourceStorageRecord().bodyHash; + auto* entryPtr = entry.release(); + auto retrieveCount = m_parameters.derivedCachedDataTypesToRetrieve.size(); + + for (auto& type : m_parameters.derivedCachedDataTypesToRetrieve) { + NetworkCache::DataKey key { originalRequest().cachePartition(), type, bodyHash }; + NetworkCache::singleton().retrieveData(key, [loader = makeRef(*this), entryPtr, type, retrieveCount] (const uint8_t* data, size_t size) mutable { + loader->m_retrievedDerivedDataCount++; + bool retrievedAll = loader->m_retrievedDerivedDataCount == retrieveCount; + std::unique_ptr<NetworkCache::Entry> entry(retrievedAll ? entryPtr : nullptr); + if (loader->hasOneRef()) + return; + if (data) { + IPC::DataReference dataReference(data, size); + loader->send(Messages::WebResourceLoader::DidRetrieveDerivedData(type, dataReference)); + } + if (retrievedAll) { + loader->sendResultForCacheEntry(WTFMove(entry)); + loader->cleanup(); + } + }); + } + return; + } + + sendResultForCacheEntry(WTFMove(entry)); + + cleanup(); } -void NetworkResourceLoader::didReceiveAuthenticationChallenge(ResourceHandle* handle, const AuthenticationChallenge& challenge) +void NetworkResourceLoader::sendResultForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) { - ASSERT_UNUSED(handle, handle == m_handle); - - // FIXME (http://webkit.org/b/115291): Since we go straight to the UI process for authentication we don't get WebCore's - // cross-origin check before asking the client for credentials. - // Therefore we are too permissive in the case where the ClientCredentialPolicy is DoNotAskClientForCrossOriginCredentials. - if (m_clientCredentialPolicy == DoNotAskClientForAnyCredentials) { - challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge); +#if ENABLE(SHAREABLE_RESOURCE) + if (!entry->shareableResourceHandle().isNull()) { + send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime())); return; } +#endif - NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(m_webPageID, m_webFrameID, challenge); + sendBuffer(*entry->buffer(), entry->buffer()->size()); + send(Messages::WebResourceLoader::DidFinishResourceLoad(currentTime())); } -void NetworkResourceLoader::didCancelAuthenticationChallenge(ResourceHandle* handle, const AuthenticationChallenge& challenge) +void NetworkResourceLoader::validateCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) { - ASSERT_UNUSED(handle, handle == m_handle); + ASSERT(!m_networkLoad); + + // If the request is already conditional then the revalidation was not triggered by the disk cache + // and we should not overwrite the existing conditional headers. + ResourceRequest revalidationRequest = originalRequest(); + if (!revalidationRequest.isConditional()) { + String eTag = entry->response().httpHeaderField(HTTPHeaderName::ETag); + String lastModified = entry->response().httpHeaderField(HTTPHeaderName::LastModified); + if (!eTag.isEmpty()) + revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfNoneMatch, eTag); + if (!lastModified.isEmpty()) + revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfModifiedSince, lastModified); + } + + m_cacheEntryForValidation = WTFMove(entry); - // This function is probably not needed (see <rdar://problem/8960124>). - notImplemented(); + startNetworkLoad(revalidationRequest); } -void NetworkResourceLoader::receivedCancellation(ResourceHandle* handle, const AuthenticationChallenge& challenge) +void NetworkResourceLoader::dispatchWillSendRequestForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) { - ASSERT_UNUSED(handle, handle == m_handle); + ASSERT(entry->redirectRequest()); + ASSERT(!m_isWaitingContinueWillSendRequestForCachedRedirect); - m_handle->cancel(); - didFail(m_handle.get(), cancelledError(m_request)); + LOG(NetworkCache, "(NetworkProcess) Executing cached redirect"); + + ++m_redirectCount; + send(Messages::WebResourceLoader::WillSendRequest(*entry->redirectRequest(), entry->response())); + m_isWaitingContinueWillSendRequestForCachedRedirect = true; } +#endif IPC::Connection* NetworkResourceLoader::messageSenderConnection() { - return connectionToWebProcess()->connection(); + return &connectionToWebProcess().connection(); } void NetworkResourceLoader::consumeSandboxExtensions() { - for (size_t i = 0, count = m_requestBodySandboxExtensions.size(); i < count; ++i) - m_requestBodySandboxExtensions[i]->consume(); + ASSERT(!m_didConsumeSandboxExtensions); - for (size_t i = 0, count = m_resourceSandboxExtensions.size(); i < count; ++i) - m_resourceSandboxExtensions[i]->consume(); + for (auto& extension : m_parameters.requestBodySandboxExtensions) + extension->consume(); - m_sandboxExtensionsAreConsumed = true; + if (auto& extension = m_parameters.resourceSandboxExtension) + extension->consume(); + + for (auto& fileReference : m_fileReferences) + fileReference->prepareForFileAccess(); + + m_didConsumeSandboxExtensions = true; } void NetworkResourceLoader::invalidateSandboxExtensions() { - if (m_sandboxExtensionsAreConsumed) { - for (size_t i = 0, count = m_requestBodySandboxExtensions.size(); i < count; ++i) - m_requestBodySandboxExtensions[i]->revoke(); - for (size_t i = 0, count = m_resourceSandboxExtensions.size(); i < count; ++i) - m_resourceSandboxExtensions[i]->revoke(); + if (m_didConsumeSandboxExtensions) { + for (auto& extension : m_parameters.requestBodySandboxExtensions) + extension->revoke(); + if (auto& extension = m_parameters.resourceSandboxExtension) + extension->revoke(); + for (auto& fileReference : m_fileReferences) + fileReference->revokeFileAccess(); + + m_didConsumeSandboxExtensions = false; } - m_requestBodySandboxExtensions.clear(); - m_resourceSandboxExtensions.clear(); - - m_sandboxExtensionsAreConsumed = false; + m_fileReferences.clear(); } #if USE(PROTECTION_SPACE_AUTH_CALLBACK) -void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace) +void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(const ProtectionSpace& protectionSpace) { - ASSERT(isMainThread()); - ASSERT_UNUSED(handle, handle == m_handle); - - m_networkLoaderClient->canAuthenticateAgainstProtectionSpace(this, protectionSpace); + NetworkProcess::singleton().canAuthenticateAgainstProtectionSpace(*this, protectionSpace); } void NetworkResourceLoader::continueCanAuthenticateAgainstProtectionSpace(bool result) { - m_handle->continueCanAuthenticateAgainstProtectionSpace(result); + if (m_networkLoad) + m_networkLoad->continueCanAuthenticateAgainstProtectionSpace(result); } - #endif -#if USE(NETWORK_CFDATA_ARRAY_CALLBACK) -bool NetworkResourceLoader::supportsDataArray() +bool NetworkResourceLoader::isAlwaysOnLoggingAllowed() const { - notImplemented(); - return false; + return sessionID().isAlwaysOnLoggingAllowed(); } -void NetworkResourceLoader::didReceiveDataArray(ResourceHandle*, CFArrayRef) -{ - ASSERT_NOT_REACHED(); - notImplemented(); -} -#endif - -#if PLATFORM(MAC) && !PLATFORM(IOS) -void NetworkResourceLoader::willStopBufferingData(ResourceHandle*, const char*, unsigned) -{ - notImplemented(); -} -#endif // PLATFORM(MAC) - } // namespace WebKit - -#endif // ENABLE(NETWORK_PROCESS) |