#pragma once
#include "CertificateInfo.h"
#include "CurlFormDataStream.h"
#include "CurlMultipartHandle.h"
#include "CurlMultipartHandleClient.h"
#include "CurlRequestSchedulerClient.h"
#include "CurlResponse.h"
#include "CurlSSLVerifier.h"
#include "FileSystem.h"
#include "NetworkLoadMetrics.h"
#include "ResourceRequest.h"
#include <wtf/Noncopyable.h>
namespace WebCore {
class CurlRequestClient;
class ResourceError;
class SharedBuffer;
class CurlRequest : public ThreadSafeRefCounted<CurlRequest>, public CurlRequestSchedulerClient, public CurlMultipartHandleClient {
WTF_MAKE_NONCOPYABLE(CurlRequest);
public:
enum class ShouldSuspend : bool {
No = false,
Yes = true
};
enum class EnableMultipart : bool {
No = false,
Yes = true
};
static Ref<CurlRequest> create(const ResourceRequest& request, CurlRequestClient& client, ShouldSuspend shouldSuspend = ShouldSuspend::No, EnableMultipart enableMultipart = EnableMultipart::No)
{
return adoptRef(*new CurlRequest(request, &client, shouldSuspend == ShouldSuspend::Yes, enableMultipart == EnableMultipart::Yes));
}
virtual ~CurlRequest() = default;
void invalidateClient();
WEBCORE_EXPORT void setUserPass(const String&, const String&);
void start(bool isSyncRequest = false);
void cancel();
WEBCORE_EXPORT void suspend();
WEBCORE_EXPORT void resume();
const ResourceRequest& resourceRequest() const { return m_request; }
bool isSyncRequest() const { return m_isSyncRequest; }
bool isCompleted() const { return !m_curlHandle; }
bool isCancelled() const { return m_cancelled; }
bool isCompletedOrCancelled() const { return isCompleted() || isCancelled(); }
const String& user() const { return m_user; }
const String& password() const { return m_password; }
WEBCORE_EXPORT void completeDidReceiveResponse();
void enableDownloadToFile();
const String& getDownloadedFilePath();
const CertificateInfo& certificateInfo() const { return m_certificateInfo; }
const NetworkLoadMetrics& networkLoadMetrics() const { return m_networkLoadMetrics; }
private:
enum class Action {
None,
ReceiveData,
StartTransfer,
FinishTransfer
};
CurlRequest(const ResourceRequest&, CurlRequestClient*, bool shouldSuspend, bool enableMultipart);
void retain() override { ref(); }
void release() override { deref(); }
CURL* handle() override { return m_curlHandle ? m_curlHandle->handle() : nullptr; }
void startWithJobManager();
void callClient(Function<void(CurlRequest&, CurlRequestClient&)>&&);
void runOnWorkerThreadIfRequired(Function<void()>&&);
CURL* setupTransfer() override;
size_t willSendData(char*, size_t, size_t);
size_t didReceiveHeader(String&&);
size_t didReceiveData(Ref<SharedBuffer>&&);
void didReceiveHeaderFromMultipart(const Vector<String>&) override;
void didReceiveDataFromMultipart(Ref<SharedBuffer>&&) override;
void didCompleteTransfer(CURLcode) override;
void didCancelTransfer() override;
void finalizeTransfer();
void invokeCancel();
void appendAcceptLanguageHeader(HTTPHeaderMap&);
void setupPOST(ResourceRequest&);
void setupPUT(ResourceRequest&);
void setupSendData(bool forPutMethod);
bool needToInvokeDidReceiveResponse() const { return m_didReceiveResponse && (!m_didNotifyResponse || !m_didReturnFromNotify); }
bool needToInvokeDidCancelTransfer() const { return m_didNotifyResponse && !m_didReturnFromNotify && m_actionAfterInvoke == Action::FinishTransfer; }
void invokeDidReceiveResponseForFile(URL&);
void invokeDidReceiveResponse(const CurlResponse&, Action);
void setRequestPaused(bool);
void setCallbackPaused(bool);
void pausedStatusChanged();
bool shouldBePaused() const { return m_isPausedOfRequest || m_isPausedOfCallback; };
void updateHandlePauseState(bool);
bool isHandlePaused() const;
void writeDataToDownloadFileIfEnabled(const SharedBuffer&);
void closeDownloadFile();
void cleanupDownloadFile();
static size_t willSendDataCallback(char*, size_t, size_t, void*);
static size_t didReceiveHeaderCallback(char*, size_t, size_t, void*);
static size_t didReceiveDataCallback(char*, size_t, size_t, void*);
CurlRequestClient* m_client { };
bool m_isSyncRequest { false };
bool m_cancelled { false };
ResourceRequest m_request;
String m_user;
String m_password;
bool m_shouldSuspend { false };
bool m_enableMultipart { false };
std::unique_ptr<CurlHandle> m_curlHandle;
CurlFormDataStream m_formDataStream;
std::unique_ptr<CurlMultipartHandle> m_multipartHandle;
CurlResponse m_response;
bool m_didReceiveResponse { false };
bool m_didNotifyResponse { false };
bool m_didReturnFromNotify { false };
Action m_actionAfterInvoke { Action::None };
CURLcode m_finishedResultCode { CURLE_OK };
bool m_isPausedOfRequest { false };
bool m_isPausedOfCallback { false };
Lock m_pauseStateMutex;
bool m_isHandlePaused { false };
Lock m_downloadMutex;
bool m_isEnabledDownloadToFile { false };
String m_downloadFilePath;
FileSystem::PlatformFileHandle m_downloadFileHandle { FileSystem::invalidPlatformFileHandle };
CertificateInfo m_certificateInfo;
NetworkLoadMetrics m_networkLoadMetrics;
};
}