diff options
Diffstat (limited to 'Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp')
| -rw-r--r-- | Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp | 654 |
1 files changed, 467 insertions, 187 deletions
diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp index 5ad12d324..cef04f346 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,325 +26,605 @@ #include "config.h" #include "NetworkResourceLoader.h" -#if ENABLE(NETWORK_PROCESS) - -#include "AuthenticationManager.h" #include "DataReference.h" #include "Logging.h" +#include "NetworkBlobRegistry.h" +#include "NetworkCache.h" #include "NetworkConnectionToWebProcess.h" -#include "NetworkProcess.h" +#include "NetworkLoad.h" #include "NetworkProcessConnectionMessages.h" -#include "NetworkResourceLoadParameters.h" -#include "PlatformCertificateInfo.h" -#include "RemoteNetworkingContext.h" -#include "ShareableResource.h" -#include "SharedMemory.h" #include "WebCoreArgumentCoders.h" -#include "WebErrors.h" #include "WebResourceLoaderMessages.h" -#include <WebCore/NotImplemented.h> -#include <WebCore/ResourceBuffer.h> -#include <WebCore/ResourceHandle.h> +#include <WebCore/BlobDataFileReference.h> +#include <WebCore/CertificateInfo.h> +#include <WebCore/HTTPHeaderNames.h> +#include <WebCore/ProtectionSpace.h> +#include <WebCore/SharedBuffer.h> +#include <WebCore/SynchronousLoaderClient.h> #include <wtf/CurrentTime.h> -#include <wtf/MainThread.h> +#include <wtf/RunLoop.h> using namespace WebCore; namespace WebKit { -NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& loadParameters, NetworkConnectionToWebProcess* connection) - : SchedulableLoader(loadParameters, connection) - , m_bytesReceived(0) - , m_handleConvertedToDownload(false) -{ - ASSERT(isMainThread()); -} +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; +}; -NetworkResourceLoader::~NetworkResourceLoader() +static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const SharedBuffer* buffer) { - ASSERT(isMainThread()); - ASSERT(!m_handle); + 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; } -void NetworkResourceLoader::start() +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) { - ASSERT(isMainThread()); + 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_parameters.webPageID && m_parameters.webFrameID) || m_parameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials); + + 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)); + } + } - // Explicit ref() balanced by a deref() in NetworkResourceLoader::resourceHandleStopped() - ref(); - - // FIXME (NetworkProcess): Create RemoteNetworkingContext with actual settings. - m_networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode(), shouldClearReferrerOnHTTPSToHTTPRedirect()); + if (originalRequest().url().protocolIsBlob()) { + ASSERT(!m_parameters.resourceSandboxExtension); + m_fileReferences.appendVector(NetworkBlobRegistry::singleton().filesInBlob(connection, originalRequest().url())); + } - consumeSandboxExtensions(); + if (synchronousReply) + m_synchronousLoadData = std::make_unique<SynchronousLoadData>(WTFMove(synchronousReply)); +} - // FIXME (NetworkProcess): Pass an actual value for defersLoading - m_handle = ResourceHandle::create(m_networkingContext.get(), request(), this, false /* defersLoading */, contentSniffingPolicy() == SniffContent); +NetworkResourceLoader::~NetworkResourceLoader() +{ + ASSERT(RunLoop::isMain()); + ASSERT(!m_networkLoad); + ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply); } -void NetworkResourceLoader::cleanup() +#if ENABLE(NETWORK_CACHE) +bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const { - ASSERT(isMainThread()); + if (!NetworkCache::singleton().isEnabled()) + return false; + if (sessionID().isEphemeral()) + return false; + if (!request.url().protocolIsInHTTPFamily()) + return false; + + return true; +} - invalidateSandboxExtensions(); +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 - if (FormData* formData = request().httpBody()) - formData->removeGeneratedFilesIfNeeded(); +bool NetworkResourceLoader::isSynchronous() const +{ + return !!m_synchronousLoadData; +} - // Tell the scheduler about this finished loader soon so it can start more network requests. - NetworkProcess::shared().networkResourceLoadScheduler().scheduleRemoveLoader(this); +void NetworkResourceLoader::start() +{ + ASSERT(RunLoop::isMain()); + + if (m_defersLoading) + return; - 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(); +#if ENABLE(NETWORK_CACHE) + if (canUseCache(originalRequest())) { + retrieveCacheEntry(originalRequest()); + return; } +#endif + + startNetworkLoad(originalRequest()); } -template<typename U> bool NetworkResourceLoader::sendAbortingOnFailure(const U& message, unsigned messageSendFlags) +#if ENABLE(NETWORK_CACHE) +void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request) { - bool result = messageSenderConnection()->send(message, messageSenderDestinationID(), messageSendFlags); - if (!result) - abort(); - return result; + ASSERT(canUseCache(request)); + + RefPtr<NetworkResourceLoader> loader(this); + NetworkCache::singleton().retrieve(request, { m_parameters.webPageID, m_parameters.webFrameID }, [loader, request](std::unique_ptr<NetworkCache::Entry> 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().containsCertificateInfo()) { + loader->startNetworkLoad(request); + return; + } + if (entry->needsValidation()) { + loader->validateCacheEntry(WTFMove(entry)); + return; + } + loader->didRetrieveCacheEntry(WTFMove(entry)); + }); } +#endif -void NetworkResourceLoader::didConvertHandleToDownload() +void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request) { - ASSERT(m_handle); - m_handleConvertedToDownload = true; + consumeSandboxExtensions(); + + if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms) + 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; + m_networkLoad = std::make_unique<NetworkLoad>(*this, parameters); } -void NetworkResourceLoader::abort() +void NetworkResourceLoader::setDefersLoading(bool defers) { - ASSERT(isMainThread()); + if (m_defersLoading == defers) + return; + m_defersLoading = defers; - if (m_handle && !m_handleConvertedToDownload) - m_handle->cancel(); + if (m_networkLoad) { + m_networkLoad->setDefersLoading(defers); + return; + } - cleanup(); + if (!m_defersLoading) + start(); } -void NetworkResourceLoader::didReceiveResponseAsync(ResourceHandle* handle, const ResourceResponse& response) +void NetworkResourceLoader::cleanup() { - ASSERT_UNUSED(handle, handle == m_handle); + ASSERT(RunLoop::isMain()); - // FIXME (NetworkProcess): Cache the response. - if (FormData* formData = request().httpBody()) - formData->removeGeneratedFilesIfNeeded(); + m_bufferingTimer.stop(); - sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponseWithCertificateInfo(response, PlatformCertificateInfo(response), isLoadingMainResource())); + invalidateSandboxExtensions(); - // m_handle will be 0 if the request got aborted above. - if (!m_handle) - return; + m_networkLoad = nullptr; + + // This will cause NetworkResourceLoader to be destroyed and therefore we do it last. + m_connection->didCleanupResourceLoader(*this); +} + +void NetworkResourceLoader::didConvertToDownload() +{ + ASSERT(m_networkLoad); + m_didConvertToDownload = true; +#if USE(NETWORK_SESSION) + m_networkLoad = nullptr; +#endif +} - if (!isLoadingMainResource()) { - // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message. - m_handle->continueDidReceiveResponse(); +void NetworkResourceLoader::abort() +{ + ASSERT(RunLoop::isMain()); + + if (m_networkLoad && !m_didConvertToDownload) { +#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::didReceiveData(ResourceHandle*, const char* data, int length, int encodedDataLength) +auto NetworkResourceLoader::didReceiveResponse(const ResourceResponse& receivedResponse) -> ShouldContinueDidReceiveResponse { - // The NetworkProcess should never get a didReceiveData callback. - // We should always be using didReceiveBuffer. - ASSERT_NOT_REACHED(); + m_response = 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) { + 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 + + bool shouldWaitContinueDidReceiveResponse = originalRequest().requester() == ResourceRequest::Requester::Main; + if (shouldSendDidReceiveResponse) { + if (isSynchronous()) + m_synchronousLoadData->response = m_response; + else { + if (!sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(m_response, shouldWaitContinueDidReceiveResponse))) + return ShouldContinueDidReceiveResponse::No; + } + } + + // 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 + + return shouldContinueDidReceiveResponse ? ShouldContinueDidReceiveResponse::Yes : ShouldContinueDidReceiveResponse::No; } -void NetworkResourceLoader::didReceiveBuffer(ResourceHandle* handle, PassRefPtr<SharedBuffer> buffer, int encodedDataLength) +void NetworkResourceLoader::didReceiveBuffer(RefPtr<SharedBuffer>&& buffer, int reportedEncodedDataLength) { - ASSERT_UNUSED(handle, handle == m_handle); +#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(); - -#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090 - ShareableResource::Handle shareableResourceHandle; - tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer.get()); - if (!shareableResourceHandle.isNull()) { - // Since we're delivering this resource by ourselves all at once, we'll abort the resource handle since we don't need anymore callbacks from ResourceHandle. - abort(); - send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime())); + if (m_bufferedData) { + m_bufferedData->append(buffer.get()); + m_bufferedDataEncodedDataLength += encodedDataLength; + startBufferingTimerIfNeeded(); return; } -#endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090 - - CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size()); - sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength)); + sendBufferMaybeAborting(*buffer, encodedDataLength); } -void NetworkResourceLoader::didFinishLoading(ResourceHandle* handle, double finishTime) +void NetworkResourceLoader::didFinishLoading(double finishTime) { - ASSERT_UNUSED(handle, handle == m_handle); +#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. + bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1); + if (!shouldContinue) + return; + } + send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime)); + } + +#if ENABLE(NETWORK_CACHE) + tryStoreAsCacheEntry(); +#endif - // FIXME (NetworkProcess): For the memory cache we'll need to update the finished status of the cached resource here. - // Such bookkeeping will need to be thread safe, as this callback is happening on a background thread. - send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime)); - cleanup(); } -void NetworkResourceLoader::didFail(ResourceHandle* handle, const ResourceError& error) +void NetworkResourceLoader::didFailLoading(const ResourceError& error) { - ASSERT_UNUSED(handle, handle == m_handle); + 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(), 0); - // FIXME (NetworkProcess): For the memory cache we'll need to update the finished status of the cached resource here. - // Such bookkeeping will need to be thread safe, as this callback is happening on a background thread. - send(Messages::WebResourceLoader::DidFailResourceLoad(error)); cleanup(); } -void NetworkResourceLoader::willSendRequestAsync(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& redirectResponse) +void NetworkResourceLoader::willSendRedirectedRequest(const ResourceRequest& request, const WebCore::ResourceRequest& redirectRequest, const 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()); - - 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(overridenRequest); + return; + } + sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(redirectRequest, redirectResponse)); - // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked waiting for 6 connections - // to complete while the WebProcess is waiting for a 7th to complete. - sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(request, redirectResponse), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply); +#if ENABLE(NETWORK_CACHE) + if (canUseCachedRedirect(request)) + NetworkCache::singleton().storeRedirect(request, redirectResponse, redirectRequest); +#else + UNUSED_PARAM(request); +#endif } void NetworkResourceLoader::continueWillSendRequest(const ResourceRequest& newRequest) { - m_suggestedRequestForWillSendRequest.updateFromDelegatePreservingOldHTTPBody(newRequest.nsURLRequest(DoNotUpdateHTTPBody)); +#if ENABLE(NETWORK_CACHE) + if (m_isWaitingContinueWillSendRequestForCachedRedirect) { + LOG(NetworkCache, "(NetworkProcess) Retrieving cached redirect"); - RunLoop::main()->dispatch(bind(&NetworkResourceLoadScheduler::receivedRedirect, &NetworkProcess::shared().networkResourceLoadScheduler(), this, m_suggestedRequestForWillSendRequest.url())); - m_handle->continueWillSendRequest(m_suggestedRequestForWillSendRequest); + if (canUseCachedRedirect(newRequest)) + retrieveCacheEntry(newRequest); + else + startNetworkLoad(newRequest); - m_suggestedRequestForWillSendRequest = ResourceRequest(); + m_isWaitingContinueWillSendRequestForCachedRedirect = false; + return; + } +#endif + m_networkLoad->continueWillSendRequest(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); - - send(Messages::WebResourceLoader::DidSendData(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; + + sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedLength)); } -bool NetworkResourceLoader::shouldUseCredentialStorage(ResourceHandle* handle) +bool NetworkResourceLoader::sendBufferMaybeAborting(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. - - // We still need this sync version, because ResourceHandle itself uses it internally, even when the delegate uses an async one. +#if PLATFORM(COCOA) + ShareableResource::Handle shareableResourceHandle; + NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer); + if (!shareableResourceHandle.isNull()) { + send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime())); + abort(); + return false; + } +#endif - return allowStoredCredentials() == AllowStoredCredentials; + IPC::SharedBufferDataReference dataReference(&buffer); + return sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength)); } -void NetworkResourceLoader::shouldUseCredentialStorageAsync(ResourceHandle* handle) +#if ENABLE(NETWORK_CACHE) +void NetworkResourceLoader::tryStoreAsCacheEntry() { - ASSERT_UNUSED(handle, handle == m_handle); + if (!canUseCache(m_networkLoad->currentRequest())) + return; + if (!m_bufferedDataForCache) + return; - handle->continueShouldUseCredentialStorage(shouldUseCredentialStorage(handle)); + // Keep the connection alive. + RefPtr<NetworkConnectionToWebProcess> connection(&connectionToWebProcess()); + RefPtr<NetworkResourceLoader> loader(this); + NetworkCache::singleton().store(m_networkLoad->currentRequest(), m_response, WTFMove(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 + }); } -void NetworkResourceLoader::didReceiveAuthenticationChallenge(ResourceHandle* handle, const AuthenticationChallenge& challenge) +void NetworkResourceLoader::didRetrieveCacheEntry(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 (clientCredentialPolicy() == DoNotAskClientForAnyCredentials) { - challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge); - return; + if (isSynchronous()) { + m_synchronousLoadData->response = entry->response(); + sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer()); + } else { + 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 } - NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(webPageID(), webFrameID(), challenge); + cleanup(); } -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); } -CoreIPC::Connection* NetworkResourceLoader::messageSenderConnection() +void NetworkResourceLoader::dispatchWillSendRequestForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry) { - return connectionToWebProcess()->connection(); + ASSERT(entry->redirectRequest()); + LOG(NetworkCache, "(NetworkProcess) Executing cached redirect"); + + ++m_redirectCount; + sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(*entry->redirectRequest(), entry->response())); + m_isWaitingContinueWillSendRequestForCachedRedirect = true; } +#endif -uint64_t NetworkResourceLoader::messageSenderDestinationID() +IPC::Connection* NetworkResourceLoader::messageSenderConnection() { - return identifier(); + return connectionToWebProcess().connection(); } -#if USE(PROTECTION_SPACE_AUTH_CALLBACK) -void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace) +void NetworkResourceLoader::consumeSandboxExtensions() { - ASSERT(isMainThread()); - ASSERT_UNUSED(handle, handle == m_handle); + ASSERT(!m_didConsumeSandboxExtensions); + + for (auto& extension : m_parameters.requestBodySandboxExtensions) + extension->consume(); - // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked - // waiting for 6 connections to complete while the WebProcess is waiting for a 7th to complete. - sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply); + if (auto& extension = m_parameters.resourceSandboxExtension) + extension->consume(); + + for (auto& fileReference : m_fileReferences) + fileReference->prepareForFileAccess(); + + m_didConsumeSandboxExtensions = true; } -void NetworkResourceLoader::continueCanAuthenticateAgainstProtectionSpace(bool result) +void NetworkResourceLoader::invalidateSandboxExtensions() { - m_handle->continueCanAuthenticateAgainstProtectionSpace(result); -} + 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; + } -#endif + m_fileReferences.clear(); +} -#if USE(NETWORK_CFDATA_ARRAY_CALLBACK) -bool NetworkResourceLoader::supportsDataArray() +template<typename T> +bool NetworkResourceLoader::sendAbortingOnFailure(T&& message, unsigned messageSendFlags) { - notImplemented(); - return false; + bool result = messageSenderConnection()->send(std::forward<T>(message), messageSenderDestinationID(), messageSendFlags); + if (!result) + abort(); + return result; } -void NetworkResourceLoader::didReceiveDataArray(ResourceHandle*, CFArrayRef) +void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(const ProtectionSpace& protectionSpace) { - ASSERT_NOT_REACHED(); - notImplemented(); -} +#if USE(PROTECTION_SPACE_AUTH_CALLBACK) + sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace)); +#else + UNUSED_PARAM(protectionSpace); #endif +} -#if PLATFORM(MAC) -void NetworkResourceLoader::willStopBufferingData(ResourceHandle*, const char*, int) +#if USE(PROTECTION_SPACE_AUTH_CALLBACK) +void NetworkResourceLoader::continueCanAuthenticateAgainstProtectionSpace(bool result) { - notImplemented(); + m_networkLoad->continueCanAuthenticateAgainstProtectionSpace(result); } -#endif // PLATFORM(MAC) +#endif } // namespace WebKit - -#endif // ENABLE(NETWORK_PROCESS) |