NetworkResourceLoader.h [plain text]
#ifndef NetworkResourceLoader_h
#define NetworkResourceLoader_h
#if ENABLE(NETWORK_PROCESS)
#include "MessageSender.h"
#include "NetworkCache.h"
#include "NetworkConnectionToWebProcessMessages.h"
#include "NetworkResourceLoadParameters.h"
#include "ShareableResource.h"
#include <WebCore/CacheValidation.h>
#include <WebCore/ResourceError.h>
#include <WebCore/ResourceHandleClient.h>
#include <WebCore/ResourceLoaderOptions.h>
#include <WebCore/ResourceRequest.h>
#include <WebCore/ResourceResponse.h>
#include <WebCore/SessionID.h>
#include <WebCore/Timer.h>
#include <wtf/MainThread.h>
#include <wtf/RunLoop.h>
typedef const struct _CFCachedURLResponse* CFCachedURLResponseRef;
namespace WebCore {
class BlobDataFileReference;
class ResourceHandle;
class ResourceRequest;
}
namespace WebKit {
class NetworkConnectionToWebProcess;
class NetworkResourceLoadParameters;
class RemoteNetworkingContext;
class SandboxExtension;
class NetworkResourceLoader : public RefCounted<NetworkResourceLoader>, public WebCore::ResourceHandleClient, public IPC::MessageSender {
public:
static Ref<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection)
{
return adoptRef(*new NetworkResourceLoader(parameters, connection, nullptr));
}
static Ref<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
{
return adoptRef(*new NetworkResourceLoader(parameters, connection, reply));
}
~NetworkResourceLoader();
const WebCore::ResourceRequest& originalRequest() const { return m_parameters.request; }
WebCore::ResourceRequest& currentRequest() { return m_currentRequest; }
WebCore::ResourceHandle* handle() const { return m_handle.get(); }
void didConvertHandleToDownload();
void start();
void abort();
void setDefersLoading(bool);
#if PLATFORM(COCOA)
static size_t fileBackedResourceMinimumSize();
#endif
void didReceiveNetworkResourceLoaderMessage(IPC::Connection&, IPC::MessageDecoder&);
#if PLATFORM(COCOA)
static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer&);
#endif
#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
void continueCanAuthenticateAgainstProtectionSpace(bool);
#endif
void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
WebCore::SharedBuffer* bufferedData() { return m_bufferedData.get(); }
const WebCore::ResourceResponse& response() const { return m_response; }
NetworkConnectionToWebProcess* connectionToWebProcess() const { return m_connection.get(); }
WebCore::SessionID sessionID() const { return m_parameters.sessionID; }
ResourceLoadIdentifier identifier() const { return m_parameters.identifier; }
struct SynchronousLoadData;
private:
NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
virtual IPC::Connection* messageSenderConnection() override;
virtual uint64_t messageSenderDestinationID() override { return m_parameters.identifier; }
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 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; }
virtual bool loadingSynchronousXHR() override { return isSynchronous(); }
#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(COCOA)
#if USE(CFNETWORK)
virtual void willCacheResponseAsync(WebCore::ResourceHandle*, CFCachedURLResponseRef) override;
#else
virtual void willCacheResponseAsync(WebCore::ResourceHandle*, NSCachedURLResponse *) override;
#endif
#endif
#if ENABLE(NETWORK_CACHE)
void didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry>);
void validateCacheEntry(std::unique_ptr<NetworkCache::Entry>);
#endif
void startNetworkLoad();
void continueDidReceiveResponse();
void cleanup();
void platformDidReceiveResponse(const WebCore::ResourceResponse&);
void startBufferingTimerIfNeeded();
void bufferingTimerFired();
bool sendBufferMaybeAborting(const WebCore::SharedBuffer&, size_t encodedDataLength);
bool isSynchronous() const;
void consumeSandboxExtensions();
void invalidateSandboxExtensions();
template<typename T> bool sendAbortingOnFailure(T&& message, unsigned messageSendFlags = 0);
const NetworkResourceLoadParameters m_parameters;
RefPtr<NetworkConnectionToWebProcess> m_connection;
RefPtr<RemoteNetworkingContext> m_networkingContext;
RefPtr<WebCore::ResourceHandle> m_handle;
WebCore::ResourceRequest m_currentRequest;
WebCore::ResourceResponse m_response;
size_t m_bytesReceived;
size_t m_bufferedDataEncodedDataLength;
RefPtr<WebCore::SharedBuffer> m_bufferedData;
std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;
Vector<RefPtr<WebCore::BlobDataFileReference>> m_fileReferences;
bool m_didConvertHandleToDownload;
bool m_didConsumeSandboxExtensions;
bool m_defersLoading;
WebCore::Timer m_bufferingTimer;
#if ENABLE(NETWORK_CACHE)
RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;
std::unique_ptr<NetworkCache::Entry> m_cacheEntryForValidation;
WebCore::RedirectChainCacheStatus m_redirectChainCacheStatus;
#endif
};
}
#endif // ENABLE(NETWORK_PROCESS)
#endif // NetworkResourceLoader_h