1 files changed, 85 insertions, 114 deletions

diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
index 7b69a5911..fe93ee054 100644
--- a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
+++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h
@@ -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,174 +26,145 @@
 #ifndef NetworkResourceLoader_h
 #define NetworkResourceLoader_h
 
-#if ENABLE(NETWORK_PROCESS)
-
-#include "HostRecord.h"
+#include "DownloadID.h"
 #include "MessageSender.h"
 #include "NetworkConnectionToWebProcessMessages.h"
+#include "NetworkLoadClient.h"
+#include "NetworkResourceLoadParameters.h"
 #include "ShareableResource.h"
-#include <WebCore/ResourceHandleClient.h>
-#include <WebCore/ResourceLoaderOptions.h>
-#include <WebCore/ResourceRequest.h>
-#include <wtf/MainThread.h>
-#include <wtf/RunLoop.h>
-
-typedef const struct _CFCachedURLResponse* CFCachedURLResponseRef;
+#include <WebCore/Timer.h>
 
 namespace WebCore {
-class ResourceBuffer;
-class ResourceHandle;
+class BlobDataFileReference;
 class ResourceRequest;
 }
 
 namespace WebKit {
 
 class NetworkConnectionToWebProcess;
-class NetworkLoaderClient;
-class NetworkResourceLoadParameters;
-class RemoteNetworkingContext;
+class NetworkLoad;
 class SandboxExtension;
 
-class NetworkResourceLoader : public RefCounted<NetworkResourceLoader>, public WebCore::ResourceHandleClient, public IPC::MessageSender {
+namespace NetworkCache {
+class Entry;
+}
+
+class NetworkResourceLoader final : public RefCounted<NetworkResourceLoader>, public NetworkLoadClient, public IPC::MessageSender {
 public:
-    static RefPtr<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection)
+    static Ref<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess& connection, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply = nullptr)
     {
-        return adoptRef(new NetworkResourceLoader(parameters, connection, nullptr));
+        return adoptRef(*new NetworkResourceLoader(parameters, connection, WTFMove(reply)));
     }
-    
-    static RefPtr<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
-    {
-        return adoptRef(new NetworkResourceLoader(parameters, connection, reply));
-    }    
-    ~NetworkResourceLoader();
+    virtual ~NetworkResourceLoader();
 
-    NetworkConnectionToWebProcess* connectionToWebProcess() const { return m_connection.get(); }
+    const WebCore::ResourceRequest& originalRequest() const { return m_parameters.request; }
 
-    WebCore::ResourceLoadPriority priority() { return m_priority; }
-    WebCore::ResourceRequest& request() { return m_request; }
-
-    WebCore::ResourceHandle* handle() const { return m_handle.get(); }
-    void didConvertHandleToDownload();
+    NetworkLoad* networkLoad() const { return m_networkLoad.get(); }
 
     void start();
     void abort();
 
-    // ResourceHandleClient methods
-    virtual void willSendRequestAsync(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse) override;
-    virtual void didSendData(WebCore::ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
-    virtual void didReceiveResponseAsync(WebCore::ResourceHandle*, const WebCore::ResourceResponse&) override;
-    virtual void didReceiveData(WebCore::ResourceHandle*, const char*, unsigned, int encodedDataLength) override;
-    virtual void didReceiveBuffer(WebCore::ResourceHandle*, PassRefPtr<WebCore::SharedBuffer>, int encodedDataLength) override;
-    virtual void didFinishLoading(WebCore::ResourceHandle*, double finishTime) override;
-    virtual void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError&) override;
-    virtual void wasBlocked(WebCore::ResourceHandle*) override;
-    virtual void cannotShowURL(WebCore::ResourceHandle*) override;
-    virtual bool shouldUseCredentialStorage(WebCore::ResourceHandle*) override;
-    virtual void shouldUseCredentialStorageAsync(WebCore::ResourceHandle*) override;
-    virtual void didReceiveAuthenticationChallenge(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) override;
-    virtual void didCancelAuthenticationChallenge(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) override;
-    virtual void receivedCancellation(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) override;
-    virtual bool usesAsyncCallbacks() override { return true; }
-
-#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
-    virtual void canAuthenticateAgainstProtectionSpaceAsync(WebCore::ResourceHandle*, const WebCore::ProtectionSpace&) override;
-#endif
-
-#if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
-    virtual bool supportsDataArray() override;
-    virtual void didReceiveDataArray(WebCore::ResourceHandle*, CFArrayRef) override;
-#endif
-
-#if PLATFORM(MAC)
-    static size_t fileBackedResourceMinimumSize();
-#if !PLATFORM(IOS)
-    virtual void willCacheResponseAsync(WebCore::ResourceHandle*, NSCachedURLResponse *) override;
-    virtual void willStopBufferingData(WebCore::ResourceHandle*, const char*, unsigned) override;
-#endif
-#endif // PLATFORM(MAC)
+    void setDefersLoading(bool);
 
     // Message handlers.
-    void didReceiveNetworkResourceLoaderMessage(IPC::Connection*, IPC::MessageDecoder&);
+    void didReceiveNetworkResourceLoaderMessage(IPC::Connection&, IPC::Decoder&);
 
-#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
-    static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
+#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
+    void continueCanAuthenticateAgainstProtectionSpace(bool);
 #endif
+    void continueWillSendRequest(WebCore::ResourceRequest&& newRequest);
 
-    bool isSynchronous() const;
-    bool isLoadingMainResource() const { return m_isLoadingMainResource; }
-    
-    void setHostRecord(HostRecord* hostRecord) { ASSERT(isMainThread()); m_hostRecord = hostRecord; }
-    HostRecord* hostRecord() const { ASSERT(isMainThread()); return m_hostRecord.get(); }
+    WebCore::SharedBuffer* bufferedData() { return m_bufferedData.get(); }
+    const WebCore::ResourceResponse& response() const { return m_response; }
 
-    template<typename T>
-    bool sendAbortingOnFailure(T&& message, unsigned messageSendFlags = 0)
-    {
-        bool result = messageSenderConnection()->send(std::forward<T>(message), messageSenderDestinationID(), messageSendFlags);
-        if (!result)
-            abort();
-        return result;
-    }
+    NetworkConnectionToWebProcess& connectionToWebProcess() { return m_connection; }
+    WebCore::SessionID sessionID() const { return m_parameters.sessionID; }
+    ResourceLoadIdentifier identifier() const { return m_parameters.identifier; }
+    uint64_t frameID() const { return m_parameters.webFrameID; }
+    uint64_t pageID() const { return m_parameters.webPageID; }
 
+    struct SynchronousLoadData;
 
+    // NetworkLoadClient.
+    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
-    void continueCanAuthenticateAgainstProtectionSpace(bool);
+    void canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&) override;
 #endif
-    void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
+    bool isSynchronous() const override;
+    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) override;
+    ShouldContinueDidReceiveResponse didReceiveResponse(WebCore::ResourceResponse&&) override;
+    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override;
+    void didFinishLoading(double finishTime) override;
+    void didFailLoading(const WebCore::ResourceError&) override;
 
-#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
-    static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
-#endif
+    void convertToDownload(DownloadID, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
+
+    bool isMainResource() const { return m_parameters.request.requester() == WebCore::ResourceRequest::Requester::Main; }
+    bool isAlwaysOnLoggingAllowed() const;
 
 private:
-    NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
+    NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess&, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&&);
 
     // IPC::MessageSender
-    virtual IPC::Connection* messageSenderConnection() override;
-    virtual uint64_t messageSenderDestinationID() override { return m_identifier; }
+    IPC::Connection* messageSenderConnection() override;
+    uint64_t messageSenderDestinationID() override { return m_parameters.identifier; }
+
+#if ENABLE(NETWORK_CACHE)
+    bool canUseCache(const WebCore::ResourceRequest&) const;
+    bool canUseCachedRedirect(const WebCore::ResourceRequest&) const;
+
+    void tryStoreAsCacheEntry();
+    void retrieveCacheEntry(const WebCore::ResourceRequest&);
+    void didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry>);
+    void sendResultForCacheEntry(std::unique_ptr<NetworkCache::Entry>);
+    void validateCacheEntry(std::unique_ptr<NetworkCache::Entry>);
+    void dispatchWillSendRequestForCacheEntry(std::unique_ptr<NetworkCache::Entry>);
+#endif
 
+    void startNetworkLoad(const WebCore::ResourceRequest&);
     void continueDidReceiveResponse();
 
     void cleanup();
     
     void platformDidReceiveResponse(const WebCore::ResourceResponse&);
 
+    void startBufferingTimerIfNeeded();
+    void bufferingTimerFired();
+    void sendBuffer(WebCore::SharedBuffer&, size_t encodedDataLength);
+
     void consumeSandboxExtensions();
     void invalidateSandboxExtensions();
 
-    RefPtr<RemoteNetworkingContext> m_networkingContext;
-    RefPtr<WebCore::ResourceHandle> m_handle;
+    const NetworkResourceLoadParameters m_parameters;
 
-    // Keep the suggested request around while asynchronously asking to update it, because some parts of the request don't survive IPC.
-    WebCore::ResourceRequest m_suggestedRequestForWillSendRequest;
+    Ref<NetworkConnectionToWebProcess> m_connection;
 
-    uint64_t m_bytesReceived;
+    std::unique_ptr<NetworkLoad> m_networkLoad;
 
-    bool m_handleConvertedToDownload;
-    std::unique_ptr<NetworkLoaderClient> m_networkLoaderClient;
+    WebCore::ResourceResponse m_response;
 
-    ResourceLoadIdentifier m_identifier;
-    uint64_t m_webPageID;
-    uint64_t m_webFrameID;
-    uint64_t m_sessionID;
-    WebCore::ResourceRequest m_request;
-    WebCore::ResourceLoadPriority m_priority;
-    WebCore::ContentSniffingPolicy m_contentSniffingPolicy;
-    WebCore::StoredCredentials m_allowStoredCredentials;
-    WebCore::ClientCredentialPolicy m_clientCredentialPolicy;
-    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
-    bool m_isLoadingMainResource;
+    size_t m_bytesReceived { 0 };
+    size_t m_bufferedDataEncodedDataLength { 0 };
+    RefPtr<WebCore::SharedBuffer> m_bufferedData;
+    unsigned m_redirectCount { 0 };
 
-    Vector<RefPtr<SandboxExtension>> m_requestBodySandboxExtensions;
-    Vector<RefPtr<SandboxExtension>> m_resourceSandboxExtensions;
-    bool m_sandboxExtensionsAreConsumed;
+    std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;
+    Vector<RefPtr<WebCore::BlobDataFileReference>> m_fileReferences;
 
-    RefPtr<NetworkConnectionToWebProcess> m_connection;
-    
-    RefPtr<HostRecord> m_hostRecord;
+    bool m_didConsumeSandboxExtensions { false };
+    bool m_defersLoading { false };
+    bool m_hasReceivedData { false };
+
+    unsigned m_retrievedDerivedDataCount { 0 };
+
+    WebCore::Timer m_bufferingTimer;
+#if ENABLE(NETWORK_CACHE)
+    RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;
+    std::unique_ptr<NetworkCache::Entry> m_cacheEntryForValidation;
+    bool m_isWaitingContinueWillSendRequestForCachedRedirect { false };
+#endif
 };
 
 } // namespace WebKit
 
-#endif // ENABLE(NETWORK_PROCESS)
-
 #endif // NetworkResourceLoader_h