SynchronousLoaderClient.cpp [plain text]
#include "config.h"
#include "SynchronousLoaderClient.h"
#include "AuthenticationChallenge.h"
#include "ResourceHandle.h"
#include "ResourceRequest.h"
#if USE(CFNETWORK)
#include <CFNetwork/CFURLConnectionPriv.h>
#endif
namespace WebCore {
SynchronousLoaderClient::~SynchronousLoaderClient()
{
}
void SynchronousLoaderClient::willSendRequest(ResourceHandle* handle, ResourceRequest& request, const ResourceResponse& )
{
if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url()))
return;
ASSERT(m_error.isNull());
m_error = platformBadResponseError();
m_isDone = true;
request = 0;
}
bool SynchronousLoaderClient::shouldUseCredentialStorage(ResourceHandle*)
{
return m_allowStoredCredentials;
}
#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
bool SynchronousLoaderClient::canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace&)
{
return true;
}
#endif
#if USE(CFNETWORK)
void SynchronousLoaderClient::didReceiveAuthenticationChallenge(ResourceHandle* handle, const AuthenticationChallenge& challenge)
{
CFURLConnectionUseCredential(handle->connection(), 0, challenge.cfURLAuthChallengeRef());
}
#endif
void SynchronousLoaderClient::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
m_response = response;
}
void SynchronousLoaderClient::didReceiveData(ResourceHandle*, const char* data, int length, int )
{
m_data.append(data, length);
}
void SynchronousLoaderClient::didFinishLoading(ResourceHandle*, double)
{
m_isDone = true;
}
void SynchronousLoaderClient::didFail(ResourceHandle*, const ResourceError& error)
{
ASSERT(m_error.isNull());
m_error = error;
m_isDone = true;
}
#if USE(CFNETWORK)
ResourceError SynchronousLoaderClient::platformBadResponseError()
{
RetainPtr<CFErrorRef> cfError = adoptCF(CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainCFNetwork, kCFURLErrorBadServerResponse, 0));
return cfError.get();
}
#endif
}