DocumentThreadableLoader.cpp [plain text]
#include "config.h"
#include "DocumentThreadableLoader.h"
#include "AuthenticationChallenge.h"
#include "Document.h"
#include "ResourceRequest.h"
#include "SecurityOrigin.h"
#include "SubresourceLoader.h"
#include "ThreadableLoaderClient.h"
namespace WebCore {
PassRefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff)
{
RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, request, callbacksSetting, contentSniff));
if (!loader->m_loader)
loader = 0;
return loader.release();
}
DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff)
: m_client(client)
, m_document(document)
{
ASSERT(document);
ASSERT(client);
m_loader = SubresourceLoader::create(document->frame(), this, request, false, callbacksSetting == SendLoadCallbacks, contentSniff == SniffContent);
}
DocumentThreadableLoader::~DocumentThreadableLoader()
{
if (m_loader)
m_loader->clearClient();
}
void DocumentThreadableLoader::cancel()
{
if (!m_loader)
return;
m_loader->cancel();
m_loader->clearClient();
m_loader = 0;
m_client = 0;
}
void DocumentThreadableLoader::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse&)
{
ASSERT(m_client);
if (!m_document->securityOrigin()->canRequest(request.url())) {
RefPtr<DocumentThreadableLoader> protect(this);
m_client->didFail();
request = ResourceRequest();
}
}
void DocumentThreadableLoader::didSendData(SubresourceLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
ASSERT(m_client);
m_client->didSendData(bytesSent, totalBytesToBeSent);
}
void DocumentThreadableLoader::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
{
ASSERT(m_client);
m_client->didReceiveResponse(response);
}
void DocumentThreadableLoader::didReceiveData(SubresourceLoader*, const char* data, int lengthReceived)
{
ASSERT(m_client);
m_client->didReceiveData(data, lengthReceived);
}
void DocumentThreadableLoader::didFinishLoading(SubresourceLoader* loader)
{
ASSERT(loader);
ASSERT(m_client);
m_client->didFinishLoading(loader->identifier());
}
void DocumentThreadableLoader::didFail(SubresourceLoader*, const ResourceError& error)
{
ASSERT(m_client);
if (error.isCancellation())
m_client->didGetCancelled();
else
m_client->didFail();
}
void DocumentThreadableLoader::receivedCancellation(SubresourceLoader*, const AuthenticationChallenge& challenge)
{
ASSERT(m_client);
m_client->didReceiveAuthenticationCancellation(challenge.failureResponse());
}
}