#include "config.h"
#include "DownloadProxy.h"
#include "APIData.h"
#include "APIDownloadClient.h"
#include "AuthenticationChallengeProxy.h"
#include "DataReference.h"
#include "DownloadProxyMap.h"
#include "WebProcessMessages.h"
#include "WebProcessPool.h"
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>
#if ENABLE(NETWORK_PROCESS)
#include "NetworkProcessMessages.h"
#include "NetworkProcessProxy.h"
#endif
using namespace WebCore;
namespace WebKit {
static uint64_t generateDownloadID()
{
static uint64_t uniqueDownloadID = 0;
return ++uniqueDownloadID;
}
PassRefPtr<DownloadProxy> DownloadProxy::create(DownloadProxyMap& downloadProxyMap, WebProcessPool& processPool, const ResourceRequest& resourceRequest)
{
return adoptRef(new DownloadProxy(downloadProxyMap, processPool, resourceRequest));
}
DownloadProxy::DownloadProxy(DownloadProxyMap& downloadProxyMap, WebProcessPool& processPool, const ResourceRequest& resourceRequest)
: m_downloadProxyMap(downloadProxyMap)
, m_processPool(&processPool)
, m_downloadID(generateDownloadID())
, m_request(resourceRequest)
{
}
DownloadProxy::~DownloadProxy()
{
ASSERT(!m_processPool);
}
void DownloadProxy::cancel()
{
if (!m_processPool)
return;
#if ENABLE(NETWORK_PROCESS)
if (m_processPool->usesNetworkProcess()) {
if (NetworkProcessProxy* networkProcess = m_processPool->networkProcess())
networkProcess->connection()->send(Messages::NetworkProcess::CancelDownload(m_downloadID), 0);
return;
}
#endif
m_processPool->sendToAllProcesses(Messages::WebProcess::CancelDownload(m_downloadID));
}
void DownloadProxy::invalidate()
{
ASSERT(m_processPool);
m_processPool = nullptr;
}
void DownloadProxy::processDidClose()
{
if (!m_processPool)
return;
m_processPool->downloadClient().processDidCrash(m_processPool.get(), this);
}
void DownloadProxy::didStart(const ResourceRequest& request)
{
m_request = request;
if (!m_processPool)
return;
m_processPool->downloadClient().didStart(m_processPool.get(), this);
}
void DownloadProxy::didReceiveAuthenticationChallenge(const AuthenticationChallenge& authenticationChallenge, uint64_t challengeID)
{
if (!m_processPool)
return;
RefPtr<AuthenticationChallengeProxy> authenticationChallengeProxy = AuthenticationChallengeProxy::create(authenticationChallenge, challengeID, m_processPool->networkingProcessConnection());
m_processPool->downloadClient().didReceiveAuthenticationChallenge(m_processPool.get(), this, authenticationChallengeProxy.get());
}
void DownloadProxy::didReceiveResponse(const ResourceResponse& response)
{
if (!m_processPool)
return;
m_processPool->downloadClient().didReceiveResponse(m_processPool.get(), this, response);
}
void DownloadProxy::didReceiveData(uint64_t length)
{
if (!m_processPool)
return;
m_processPool->downloadClient().didReceiveData(m_processPool.get(), this, length);
}
void DownloadProxy::shouldDecodeSourceDataOfMIMEType(const String& mimeType, bool& result)
{
result = false;
if (!m_processPool)
return;
result = m_processPool->downloadClient().shouldDecodeSourceDataOfMIMEType(m_processPool.get(), this, mimeType);
}
void DownloadProxy::decideDestinationWithSuggestedFilename(const String& filename, String& destination, bool& allowOverwrite, SandboxExtension::Handle& sandboxExtensionHandle)
{
allowOverwrite = false;
if (!m_processPool)
return;
destination = m_processPool->downloadClient().decideDestinationWithSuggestedFilename(m_processPool.get(), this, filename, allowOverwrite);
if (!destination.isNull())
SandboxExtension::createHandle(destination, SandboxExtension::ReadWrite, sandboxExtensionHandle);
}
void DownloadProxy::didCreateDestination(const String& path)
{
if (!m_processPool)
return;
m_processPool->downloadClient().didCreateDestination(m_processPool.get(), this, path);
}
void DownloadProxy::didFinish()
{
if (!m_processPool)
return;
m_processPool->downloadClient().didFinish(m_processPool.get(), this);
m_downloadProxyMap.downloadFinished(this);
}
static RefPtr<API::Data> createData(const IPC::DataReference& data)
{
if (data.isEmpty())
return 0;
return API::Data::create(data.data(), data.size());
}
void DownloadProxy::didFail(const ResourceError& error, const IPC::DataReference& resumeData)
{
if (!m_processPool)
return;
m_resumeData = createData(resumeData);
m_processPool->downloadClient().didFail(m_processPool.get(), this, error);
m_downloadProxyMap.downloadFinished(this);
}
void DownloadProxy::didCancel(const IPC::DataReference& resumeData)
{
m_resumeData = createData(resumeData);
m_processPool->downloadClient().didCancel(m_processPool.get(), this);
m_downloadProxyMap.downloadFinished(this);
}
}