webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

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)