SubresourceLoader.cpp [plain text]
#include "config.h"
#include "SubresourceLoader.h"
#include "CachedResourceLoader.h"
#include "Document.h"
#include "DocumentLoader.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "Logging.h"
#include "MemoryCache.h"
#include "Page.h"
#include "PageActivityAssertionToken.h"
#include "ResourceBuffer.h"
#include <wtf/RefCountedLeakCounter.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/CString.h>
namespace WebCore {
DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, subresourceLoaderCounter, ("SubresourceLoader"));
SubresourceLoader::RequestCountTracker::RequestCountTracker(CachedResourceLoader* cachedResourceLoader, CachedResource* resource)
: m_cachedResourceLoader(cachedResourceLoader)
, m_resource(resource)
{
m_cachedResourceLoader->incrementRequestCount(m_resource);
}
SubresourceLoader::RequestCountTracker::~RequestCountTracker()
{
m_cachedResourceLoader->decrementRequestCount(m_resource);
}
SubresourceLoader::SubresourceLoader(Frame* frame, CachedResource* resource, const ResourceLoaderOptions& options)
: ResourceLoader(frame, options)
, m_resource(resource)
, m_loadingMultipartContent(false)
, m_state(Uninitialized)
, m_requestCountTracker(adoptPtr(new RequestCountTracker(frame->document()->cachedResourceLoader(), resource)))
{
#ifndef NDEBUG
subresourceLoaderCounter.increment();
#endif
}
SubresourceLoader::~SubresourceLoader()
{
ASSERT(m_state != Initialized);
ASSERT(reachedTerminalState());
#ifndef NDEBUG
subresourceLoaderCounter.decrement();
#endif
}
PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, CachedResource* resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
{
RefPtr<SubresourceLoader> subloader(adoptRef(new SubresourceLoader(frame, resource, options)));
if (!subloader->init(request))
return 0;
return subloader.release();
}
CachedResource* SubresourceLoader::cachedResource()
{
return m_resource;
}
void SubresourceLoader::cancelIfNotFinishing()
{
if (m_state != Initialized)
return;
ResourceLoader::cancel();
}
bool SubresourceLoader::init(const ResourceRequest& request)
{
if (!ResourceLoader::init(request))
return false;
ASSERT(!reachedTerminalState());
m_state = Initialized;
if (m_frame && m_frame->page() && !m_activityAssertion)
m_activityAssertion = m_frame->page()->createActivityToken();
m_documentLoader->addSubresourceLoader(this);
return true;
}
bool SubresourceLoader::isSubresourceLoader()
{
return true;
}
void SubresourceLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
{
KURL previousURL = request().url();
RefPtr<SubresourceLoader> protect(this);
ASSERT(!newRequest.isNull());
if (!redirectResponse.isNull()) {
if (newRequest.isConditional() && m_resource->resourceToRevalidate() && newRequest.url() != m_resource->resourceToRevalidate()->response().url()) {
newRequest.makeUnconditional();
memoryCache()->revalidationFailed(m_resource);
}
if (!m_documentLoader->cachedResourceLoader()->canRequest(m_resource->type(), newRequest.url())) {
cancel();
return;
}
if (m_resource->type() == CachedResource::ImageResource && m_documentLoader->cachedResourceLoader()->shouldDeferImageLoad(newRequest.url())) {
cancel();
return;
}
m_resource->willSendRequest(newRequest, redirectResponse);
}
if (newRequest.isNull() || reachedTerminalState())
return;
ResourceLoader::willSendRequest(newRequest, redirectResponse);
if (newRequest.isNull())
cancel();
}
void SubresourceLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
ASSERT(m_state == Initialized);
RefPtr<SubresourceLoader> protect(this);
m_resource->didSendData(bytesSent, totalBytesToBeSent);
}
void SubresourceLoader::didReceiveResponse(const ResourceResponse& response)
{
ASSERT(!response.isNull());
ASSERT(m_state == Initialized);
RefPtr<SubresourceLoader> protect(this);
if (m_resource->resourceToRevalidate()) {
if (response.httpStatusCode() == 304) {
m_resource->setResponse(response);
memoryCache()->revalidationSucceeded(m_resource, response);
if (!reachedTerminalState())
ResourceLoader::didReceiveResponse(response);
return;
}
memoryCache()->revalidationFailed(m_resource);
}
m_resource->responseReceived(response);
if (reachedTerminalState())
return;
ResourceLoader::didReceiveResponse(response);
if (reachedTerminalState())
return;
if (response.isMultipart() && m_resource->type() != CachedResource::MainResource) {
m_loadingMultipartContent = true;
m_requestCountTracker.clear();
if (!m_resource->isImage()) {
cancel();
return;
}
}
RefPtr<ResourceBuffer> buffer = resourceData();
if (m_loadingMultipartContent && buffer && buffer->size()) {
RefPtr<ResourceBuffer> copiedData = ResourceBuffer::create(buffer->data(), buffer->size());
m_resource->finishLoading(copiedData.get());
clearResourceData();
m_documentLoader->subresourceLoaderFinishedLoadingOnePart(this);
didFinishLoadingOnePart(0);
}
checkForHTTPStatusCodeError();
}
void SubresourceLoader::didReceiveData(const char* data, int length, long long encodedDataLength, DataPayloadType dataPayloadType)
{
didReceiveDataOrBuffer(data, length, 0, encodedDataLength, dataPayloadType);
}
void SubresourceLoader::didReceiveBuffer(PassRefPtr<SharedBuffer> buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
didReceiveDataOrBuffer(0, 0, buffer, encodedDataLength, dataPayloadType);
}
void SubresourceLoader::didReceiveDataOrBuffer(const char* data, int length, PassRefPtr<SharedBuffer> prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
return;
ASSERT(!m_resource->resourceToRevalidate());
ASSERT(!m_resource->errorOccurred());
ASSERT(m_state == Initialized);
RefPtr<SubresourceLoader> protect(this);
RefPtr<SharedBuffer> buffer = prpBuffer;
ResourceLoader::didReceiveDataOrBuffer(data, length, buffer, encodedDataLength, dataPayloadType);
if (!m_loadingMultipartContent) {
if (ResourceBuffer* resourceData = this->resourceData())
m_resource->addDataBuffer(resourceData);
else
m_resource->addData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
}
}
bool SubresourceLoader::checkForHTTPStatusCodeError()
{
if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
return false;
m_state = Finishing;
m_activityAssertion.clear();
m_resource->error(CachedResource::LoadError);
cancel();
return true;
}
void SubresourceLoader::didFinishLoading(double finishTime)
{
if (m_state != Initialized)
return;
ASSERT(!reachedTerminalState());
ASSERT(!m_resource->resourceToRevalidate());
ASSERT(!m_resource->errorOccurred());
LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
RefPtr<SubresourceLoader> protect(this);
CachedResourceHandle<CachedResource> protectResource(m_resource);
m_state = Finishing;
m_activityAssertion.clear();
m_resource->setLoadFinishTime(finishTime);
m_resource->finishLoading(resourceData());
if (wasCancelled())
return;
m_resource->finish();
ASSERT(!reachedTerminalState());
didFinishLoadingOnePart(finishTime);
notifyDone();
if (reachedTerminalState())
return;
releaseResources();
}
void SubresourceLoader::didFail(const ResourceError& error)
{
if (m_state != Initialized)
return;
ASSERT(!reachedTerminalState());
LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
RefPtr<SubresourceLoader> protect(this);
CachedResourceHandle<CachedResource> protectResource(m_resource);
m_state = Finishing;
m_activityAssertion.clear();
if (m_resource->resourceToRevalidate())
memoryCache()->revalidationFailed(m_resource);
m_resource->setResourceError(error);
if (!m_resource->isPreloaded())
memoryCache()->remove(m_resource);
m_resource->error(CachedResource::LoadError);
cleanupForError(error);
notifyDone();
if (reachedTerminalState())
return;
releaseResources();
}
void SubresourceLoader::willCancel(const ResourceError& error)
{
if (m_state != Initialized)
return;
ASSERT(!reachedTerminalState());
LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().string().latin1().data());
RefPtr<SubresourceLoader> protect(this);
m_state = Finishing;
m_activityAssertion.clear();
if (m_resource->resourceToRevalidate())
memoryCache()->revalidationFailed(m_resource);
m_resource->setResourceError(error);
memoryCache()->remove(m_resource);
}
void SubresourceLoader::didCancel(const ResourceError&)
{
if (m_state == Uninitialized)
return;
m_resource->cancelLoad();
notifyDone();
}
void SubresourceLoader::notifyDone()
{
if (reachedTerminalState())
return;
m_requestCountTracker.clear();
m_documentLoader->cachedResourceLoader()->loadDone(m_resource);
if (reachedTerminalState())
return;
m_documentLoader->removeSubresourceLoader(this);
}
void SubresourceLoader::releaseResources()
{
ASSERT(!reachedTerminalState());
if (m_state != Uninitialized)
m_resource->clearLoader();
m_resource = 0;
ResourceLoader::releaseResources();
}
}