#ifndef DownloadManager_h
#define DownloadManager_h
#include "DownloadID.h"
#include "NetworkDataTask.h"
#include "PendingDownload.h"
#include "SandboxExtension.h"
#include <WebCore/NotImplemented.h>
#include <wtf/Forward.h>
#include <wtf/HashMap.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
#if !USE(NETWORK_SESSION)
class ResourceHandle;
#endif
class ResourceRequest;
class ResourceResponse;
class SessionID;
}
namespace IPC {
class Connection;
class DataReference;
}
namespace WebKit {
class AuthenticationManager;
class Download;
class PendingDownload;
class DownloadManager {
WTF_MAKE_NONCOPYABLE(DownloadManager);
public:
class Client {
public:
virtual ~Client() { }
virtual void didCreateDownload() = 0;
virtual void didDestroyDownload() = 0;
virtual IPC::Connection* downloadProxyConnection() = 0;
virtual AuthenticationManager& downloadsAuthenticationManager() = 0;
#if USE(NETWORK_SESSION)
virtual void pendingDownloadCanceled(DownloadID) = 0;
#endif
};
explicit DownloadManager(Client&);
void startDownload(WebCore::SessionID, DownloadID, const WebCore::ResourceRequest&, const String& suggestedName = { });
#if USE(NETWORK_SESSION)
std::pair<RefPtr<NetworkDataTask>, std::unique_ptr<PendingDownload>> dataTaskBecameDownloadTask(DownloadID, std::unique_ptr<Download>&&);
void continueCanAuthenticateAgainstProtectionSpace(DownloadID, bool canAuthenticate);
void continueWillSendRequest(DownloadID, WebCore::ResourceRequest&&);
void willDecidePendingDownloadDestination(NetworkDataTask&, ResponseCompletionHandler&&);
void continueDecidePendingDownloadDestination(DownloadID, String destination, const SandboxExtension::Handle&, bool allowOverwrite);
#else
void convertHandleToDownload(DownloadID, WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
#endif
void resumeDownload(WebCore::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, const SandboxExtension::Handle&);
void cancelDownload(DownloadID);
Download* download(DownloadID downloadID) { return m_downloads.get(downloadID); }
void downloadFinished(Download*);
bool isDownloading() const { return !m_downloads.isEmpty(); }
uint64_t activeDownloadCount() const { return m_downloads.size(); }
void didCreateDownload();
void didDestroyDownload();
IPC::Connection* downloadProxyConnection();
AuthenticationManager& downloadsAuthenticationManager();
private:
Client& m_client;
#if USE(NETWORK_SESSION)
HashMap<DownloadID, std::unique_ptr<PendingDownload>> m_pendingDownloads;
HashMap<DownloadID, std::pair<RefPtr<NetworkDataTask>, ResponseCompletionHandler>> m_downloadsWaitingForDestination;
HashMap<DownloadID, RefPtr<NetworkDataTask>> m_downloadsAfterDestinationDecided;
#endif
HashMap<DownloadID, std::unique_ptr<Download>> m_downloads;
};
}
#endif // DownloadManager_h