ResourceHandleAndroid.cpp [plain text]
#include "config.h"
#include "ResourceHandle.h"
#include "CachedResourceLoader.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 "Settings.h"
#include <wtf/text/CString.h>
namespace WebCore {
ResourceHandleInternal::~ResourceHandleInternal()
{
}
ResourceHandle::~ResourceHandle()
{
}
bool ResourceHandle::start(NetworkingContext* context)
{
MainResourceLoader* mainLoader = context->mainResourceLoader();
bool isMainResource = static_cast<void*>(mainLoader) == static_cast<void*>(client());
RefPtr<ResourceLoaderAndroid> loader = ResourceLoaderAndroid::start(this, d->m_firstRequest, context->frameLoaderClient(), isMainResource, false);
if (loader) {
d->m_loader = loader.release();
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::platformSetDefersLoading(bool)
{
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 encodedDataLength)
{
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(NetworkingContext* context, const ResourceRequest& request,
StoredCredentials, ResourceError& error, ResourceResponse& response, WTF::Vector<char>& data)
{
SyncLoader s(error, response, data);
RefPtr<ResourceHandle> h = adoptRef(new ResourceHandle(request, &s, false, false));
ResourceLoaderAndroid::start(h.get(), request, context->frameLoaderClient(), false, true);
}
}