CurlResourceHandleDelegate.cpp [plain text]
#include "config.h"
#include "CurlResourceHandleDelegate.h"
#include "CurlCacheManager.h"
#include "CurlRequest.h"
#include "NetworkStorageSession.h"
#include "ResourceHandle.h"
#include "ResourceHandleClient.h"
#include "ResourceHandleInternal.h"
#include <wtf/CompletionHandler.h>
#if USE(CURL)
namespace WebCore {
CurlResourceHandleDelegate::CurlResourceHandleDelegate(ResourceHandle& handle)
: m_handle(handle)
{
}
void CurlResourceHandleDelegate::ref()
{
m_handle.ref();
}
void CurlResourceHandleDelegate::deref()
{
m_handle.deref();
}
bool CurlResourceHandleDelegate::cancelledOrClientless()
{
return m_handle.cancelledOrClientless();
}
ResourceHandleClient* CurlResourceHandleDelegate::client() const
{
return m_handle.client();
}
ResourceHandleInternal* CurlResourceHandleDelegate::d()
{
return m_handle.getInternal();
}
void CurlResourceHandleDelegate::curlDidSendData(CurlRequest& request, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
UNUSED_PARAM(request);
ASSERT(isMainThread());
if (cancelledOrClientless())
return;
client()->didSendData(&m_handle, bytesSent, totalBytesToBeSent);
}
static void handleCookieHeaders(const CurlResponse& response)
{
static const auto setCookieHeader = "set-cookie: ";
const auto& storageSession = NetworkStorageSession::defaultStorageSession();
const auto& cookieJar = storageSession.cookieStorage();
for (const auto& header : response.headers) {
if (header.startsWithIgnoringASCIICase(setCookieHeader)) {
const auto contents = header.right(header.length() - strlen(setCookieHeader));
cookieJar.setCookiesFromHTTPResponse(storageSession, response.url, contents);
}
}
}
void CurlResourceHandleDelegate::curlDidReceiveResponse(CurlRequest& request, const CurlResponse& receivedResponse)
{
ASSERT(isMainThread());
ASSERT(!d()->m_defersLoading);
if (cancelledOrClientless())
return;
m_response = ResourceResponse(receivedResponse);
m_response.setCertificateInfo(request.certificateInfo().isolatedCopy());
m_response.setDeprecatedNetworkLoadMetrics(request.networkLoadMetrics().isolatedCopy());
handleCookieHeaders(receivedResponse);
if (m_response.shouldRedirect()) {
m_handle.willSendRequest();
return;
}
if (m_response.isUnauthorized()) {
AuthenticationChallenge challenge(receivedResponse, d()->m_authFailureCount, m_response, &m_handle);
m_handle.didReceiveAuthenticationChallenge(challenge);
d()->m_authFailureCount++;
return;
}
if (m_response.isNotModified()) {
URL cacheUrl = m_response.url();
cacheUrl.removeFragmentIdentifier();
if (CurlCacheManager::singleton().getCachedResponse(cacheUrl, m_response)) {
if (d()->m_addedCacheValidationHeaders) {
m_response.setHTTPStatusCode(200);
m_response.setHTTPStatusText("OK");
}
}
}
CurlCacheManager::singleton().didReceiveResponse(m_handle, m_response);
m_handle.didReceiveResponse(ResourceResponse(m_response), [this, protectedHandle = makeRef(m_handle)] {
m_handle.continueAfterDidReceiveResponse();
});
}
void CurlResourceHandleDelegate::curlDidReceiveBuffer(CurlRequest& request, Ref<SharedBuffer>&& buffer)
{
UNUSED_PARAM(request);
ASSERT(isMainThread());
if (cancelledOrClientless())
return;
CurlCacheManager::singleton().didReceiveData(m_handle, buffer->data(), buffer->size());
client()->didReceiveBuffer(&m_handle, WTFMove(buffer), buffer->size());
}
void CurlResourceHandleDelegate::curlDidComplete(CurlRequest& request)
{
ASSERT(isMainThread());
if (cancelledOrClientless())
return;
m_response.setDeprecatedNetworkLoadMetrics(request.networkLoadMetrics().isolatedCopy());
CurlCacheManager::singleton().didFinishLoading(m_handle);
client()->didFinishLoading(&m_handle);
}
void CurlResourceHandleDelegate::curlDidFailWithError(CurlRequest& request, const ResourceError& resourceError)
{
UNUSED_PARAM(request);
ASSERT(isMainThread());
if (cancelledOrClientless())
return;
CurlCacheManager::singleton().didFail(m_handle);
client()->didFail(&m_handle, resourceError);
}
}
#endif