ResourceHandleAndroid.cpp [plain text]
#include "config.h"
#include "ResourceHandle.h"
#include "DocLoader.h"
#include "DocumentLoader.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "MainResourceLoader.h"
#include "NotImplemented.h"
#include "ResourceHandleClient.h"
#include "ResourceHandleInternal.h"
#include "ResourceLoaderAndroid.h"
#include <wtf/text/CString.h>
namespace WebCore {
ResourceHandleInternal::~ResourceHandleInternal()
{
}
ResourceHandle::~ResourceHandle()
{
}
bool ResourceHandle::start(Frame* frame)
{
DocumentLoader* docLoader = frame->loader()->activeDocumentLoader();
MainResourceLoader* mainLoader = docLoader->mainResourceLoader();
bool isMainResource = mainLoader && (mainLoader->handle() == this);
PassRefPtr<ResourceLoaderAndroid> loader = ResourceLoaderAndroid::start(this, d->m_request, frame->loader()->client(), isMainResource, false);
if (loader) {
d->m_loader = loader;
return true;
}
return false;
}
void ResourceHandle::cancel()
{
if (d->m_loader)
d->m_loader->cancel();
}
PassRefPtr<SharedBuffer> ResourceHandle::bufferedData()
{
notImplemented();
return 0;
}
bool ResourceHandle::supportsBufferedData()
{
notImplemented();
return false;
}
void ResourceHandle::setDefersLoading(bool defers)
{
notImplemented();
}
bool ResourceHandle::willLoadFromCache(ResourceRequest& request, Frame*)
{
request.setCachePolicy(ReturnCacheDataDontLoad);
FormData* formData = request.httpBody();
return ResourceLoaderAndroid::willLoadFromCache(request.url(), formData ? formData->identifier() : 0);
}
bool ResourceHandle::loadsBlocked()
{
return false;
}
class SyncLoader : public ResourceHandleClient {
public:
SyncLoader(ResourceError& error, ResourceResponse& response, WTF::Vector<char>& data)
{
m_error = &error;
m_response = &response;
m_data = &data;
}
~SyncLoader() {}
virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
*m_response = response;
}
virtual void didReceiveData(ResourceHandle*, const char* data, int len, int lengthReceived)
{
m_data->append(data, len);
}
virtual void didFail(ResourceHandle*, const ResourceError& error)
{
*m_error = error;
}
private:
ResourceError* m_error;
ResourceResponse* m_response;
WTF::Vector<char>* m_data;
};
void ResourceHandle::loadResourceSynchronously(const ResourceRequest& request,
StoredCredentials ,
ResourceError& error, ResourceResponse& response, WTF::Vector<char>& data,
Frame* frame)
{
SyncLoader s(error, response, data);
ResourceHandle h(request, &s, false, false, false);
ResourceLoaderAndroid::start(&h, request, frame->loader()->client(), false, true);
}
}