ResourceHandleQt.cpp [plain text]
#include "config.h"
#include "ResourceHandle.h"
#include "ChromeClientQt.h"
#include "CachedResourceLoader.h"
#include "Frame.h"
#include "FrameNetworkingContext.h"
#include "FrameLoaderClientQt.h"
#include "NotImplemented.h"
#include "Page.h"
#include "QNetworkReplyHandler.h"
#include "ResourceHandleClient.h"
#include "ResourceHandleInternal.h"
#include "SharedBuffer.h"
#include <QAbstractNetworkCache>
#include <QCoreApplication>
#include <QUrl>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
namespace WebCore {
class WebCoreSynchronousLoader : public ResourceHandleClient {
public:
WebCoreSynchronousLoader(ResourceError& error, ResourceResponse& response, Vector<char>& data)
: m_error(error)
, m_response(response)
, m_data(data)
{}
virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = response; }
virtual void didReceiveData(ResourceHandle*, const char* data, int length, int) { m_data.append(data, length); }
virtual void didFinishLoading(ResourceHandle*, double ) {}
virtual void didFail(ResourceHandle*, const ResourceError& error) { m_error = error; }
private:
ResourceError& m_error;
ResourceResponse& m_response;
Vector<char>& m_data;
};
ResourceHandleInternal::~ResourceHandleInternal()
{
}
ResourceHandle::~ResourceHandle()
{
if (d->m_job)
cancel();
}
bool ResourceHandle::start(NetworkingContext* context)
{
if (context && !context->isValid())
return false;
if (!d->m_user.isEmpty() || !d->m_pass.isEmpty()) {
KURL urlWithCredentials(firstRequest().url());
urlWithCredentials.setUser(d->m_user);
urlWithCredentials.setPass(d->m_pass);
d->m_firstRequest.setURL(urlWithCredentials);
}
getInternal()->m_context = context;
ResourceHandleInternal *d = getInternal();
d->m_job = new QNetworkReplyHandler(this, QNetworkReplyHandler::AsynchronousLoad, d->m_defersLoading);
return true;
}
void ResourceHandle::cancel()
{
if (d->m_job) {
d->m_job->abort();
d->m_job = 0;
}
}
bool ResourceHandle::loadsBlocked()
{
return false;
}
bool ResourceHandle::willLoadFromCache(ResourceRequest& request, Frame* frame)
{
if (!frame)
return false;
QNetworkAccessManager* manager = 0;
QAbstractNetworkCache* cache = 0;
if (frame->loader()->networkingContext()) {
manager = frame->loader()->networkingContext()->networkAccessManager();
cache = manager->cache();
}
if (!cache)
return false;
QNetworkCacheMetaData data = cache->metaData(request.url());
if (data.isValid()) {
request.setCachePolicy(ReturnCacheDataDontLoad);
return true;
}
return false;
}
bool ResourceHandle::supportsBufferedData()
{
return false;
}
PassRefPtr<SharedBuffer> ResourceHandle::bufferedData()
{
ASSERT_NOT_REACHED();
return 0;
}
void ResourceHandle::loadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials , ResourceError& error, ResourceResponse& response, Vector<char>& data)
{
WebCoreSynchronousLoader syncLoader(error, response, data);
RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, true, false));
ResourceHandleInternal* d = handle->getInternal();
if (!d->m_user.isEmpty() || !d->m_pass.isEmpty()) {
KURL urlWithCredentials(d->m_firstRequest.url());
urlWithCredentials.setUser(d->m_user);
urlWithCredentials.setPass(d->m_pass);
d->m_firstRequest.setURL(urlWithCredentials);
}
d->m_context = context;
d->m_job = new QNetworkReplyHandler(handle.get(), QNetworkReplyHandler::SynchronousLoad, true);
d->m_job->setLoadingDeferred(false);
}
void ResourceHandle::platformSetDefersLoading(bool defers)
{
if (!d->m_job)
return;
d->m_job->setLoadingDeferred(defers);
}
}