void ResourceLoader::start()
{
ASSERT(!m_loader);
ASSERT(!m_request.isNull());
ASSERT(m_deferredRequest.isNull());
m_host->willStartLoadingResource(m_request);
if (m_options.synchronousPolicy == RequestSynchronously) {
requestSynchronously();
return;
}
if (m_defersLoading) {
m_deferredRequest = m_request;
return;
}
if (m_state == Terminated)
return;
RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
m_connectionState = ConnectionStateStarted;
m_loader = adoptPtr(WebKit::Platform::current()->createURLLoader());
ASSERT(m_loader);
WebKit::WrappedResourceRequest wrappedRequest(m_request);
wrappedRequest.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
m_loader->loadAsynchronously(wrappedRequest, this);
}
void ResourceLoader::start(const ResourceRequest& request,
WebTaskRunner* loadingTaskRunner,
bool defersLoading) {
DCHECK(!m_loader);
if (m_resource->options().synchronousPolicy == RequestSynchronously &&
defersLoading) {
cancel();
return;
}
m_loader = WTF::wrapUnique(Platform::current()->createURLLoader());
DCHECK(m_loader);
m_loader->setDefersLoading(defersLoading);
m_loader->setLoadingTaskRunner(loadingTaskRunner);
if (m_isCacheAwareLoadingActivated) {
// Override cache policy for cache-aware loading. If this request fails, a
// reload with original request will be triggered in didFail().
ResourceRequest cacheAwareRequest(request);
cacheAwareRequest.setCachePolicy(WebCachePolicy::ReturnCacheDataIfValid);
m_loader->loadAsynchronously(WrappedResourceRequest(cacheAwareRequest),
this);
return;
}
if (m_resource->options().synchronousPolicy == RequestSynchronously)
requestSynchronously(request);
else
m_loader->loadAsynchronously(WrappedResourceRequest(request), this);
}
void ResourceLoader::start()
{
ASSERT(!m_loader);
ASSERT(!m_request.isNull());
ASSERT(m_deferredRequest.isNull());
m_fetcher->willStartLoadingResource(m_resource, m_request);
if (m_options.synchronousPolicy == RequestSynchronously) {
requestSynchronously();
return;
}
if (m_defersLoading) {
m_deferredRequest = m_request;
return;
}
if (m_state == Terminated)
return;
RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
m_connectionState = ConnectionStateStarted;
m_loader = adoptPtr(Platform::current()->createURLLoader());
ASSERT(m_loader);
m_loader->setLoadingTaskRunner(m_fetcher->loadingTaskRunner());
WrappedResourceRequest wrappedRequest(m_request);
m_loader->loadAsynchronously(wrappedRequest, this);
}
void ResourceLoader::start()
{
ASSERT(!m_loader);
ASSERT(!m_request.isNull());
ASSERT(m_deferredRequest.isNull());
if (responseNeedsAccessControlCheck() && m_fetcher->isControlledByServiceWorker()) {
m_fallbackRequestForServiceWorker = adoptPtr(new ResourceRequest(m_request));
m_fallbackRequestForServiceWorker->setSkipServiceWorker(true);
}
m_fetcher->willStartLoadingResource(m_resource, m_request);
if (m_options.synchronousPolicy == RequestSynchronously) {
requestSynchronously();
return;
}
if (m_defersLoading) {
m_deferredRequest = m_request;
return;
}
if (m_state == Terminated)
return;
RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
m_connectionState = ConnectionStateStarted;
m_loader = adoptPtr(Platform::current()->createURLLoader());
ASSERT(m_loader);
WrappedResourceRequest wrappedRequest(m_request);
m_loader->loadAsynchronously(wrappedRequest, this);
}
void ResourceLoader::changeToSynchronous()
{
ASSERT(m_options.synchronousPolicy == RequestAsynchronously);
ASSERT(m_loader);
m_loader->cancel();
m_loader.clear();
m_request.setPriority(ResourceLoadPriorityHighest);
m_connectionState = ConnectionStateNew;
requestSynchronously();
}