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()
{
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 ResourceHandleInternal::start()
{
if (m_state != ConnectionStateNew)
CRASH();
m_state = ConnectionStateStarted;
m_loader.set(webKitClient()->createURLLoader());
ASSERT(m_loader.get());
WrappedResourceRequest wrappedRequest(m_request);
wrappedRequest.setAllowStoredCredentials(allowStoredCredentials());
m_loader->loadAsynchronously(wrappedRequest, this);
}
void ResourceLoader::start()
{
ASSERT(!m_loader);
ASSERT(!m_request.isNull());
m_host->willStartLoadingResource(m_resource, m_request);
if (m_state == Terminated)
return;
RELEASE_ASSERT(m_connectionState == ConnectionStateNew);
m_connectionState = ConnectionStateStarted;
m_loader = adoptPtr(blink::Platform::current()->createURLLoader());
ASSERT(m_loader);
blink::WrappedResourceRequest wrappedRequest(m_request);
m_loader->loadAsynchronously(wrappedRequest, this);
}
PingLoader::PingLoader(LocalFrame* frame, ResourceRequest& request, const FetchInitiatorInfo& initiatorInfo, StoredCredentials credentialsAllowed)
: LocalFrameLifecycleObserver(frame)
, m_timeout(this, &PingLoader::timeout)
, m_url(request.url())
, m_identifier(createUniqueIdentifier())
{
frame->loader().client()->didDispatchPingLoader(request.url());
TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD, "data", InspectorSendRequestEvent::data(m_identifier, frame, request));
InspectorInstrumentation::willSendRequest(frame, m_identifier, frame->loader().documentLoader(), request, ResourceResponse(), initiatorInfo);
m_loader = adoptPtr(Platform::current()->createURLLoader());
ASSERT(m_loader);
WrappedResourceRequest wrappedRequest(request);
wrappedRequest.setAllowStoredCredentials(credentialsAllowed == AllowStoredCredentials);
m_loader->loadAsynchronously(wrappedRequest, this);
// If the server never responds, FrameLoader won't be able to cancel this load and
// we'll sit here waiting forever. Set a very generous timeout, just in case.
m_timeout.startOneShot(60000, BLINK_FROM_HERE);
}
PingLoader::PingLoader(LocalFrame* frame, ResourceRequest& request, const FetchInitiatorInfo& initiatorInfo, StoredCredentials credentialsAllowed)
: PageLifecycleObserver(frame->page())
, m_timeout(this, &PingLoader::timeout)
, m_url(request.url())
, m_identifier(createUniqueIdentifier())
{
frame->loader().client()->didDispatchPingLoader(request.url());
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceSendRequest", "data", InspectorSendRequestEvent::data(m_identifier, frame, request));
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack());
// FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
InspectorInstrumentation::willSendRequest(frame, m_identifier, frame->loader().documentLoader(), request, ResourceResponse(), initiatorInfo);
m_loader = adoptPtr(blink::Platform::current()->createURLLoader());
ASSERT(m_loader);
blink::WrappedResourceRequest wrappedRequest(request);
wrappedRequest.setAllowStoredCredentials(credentialsAllowed == AllowStoredCredentials);
m_loader->loadAsynchronously(wrappedRequest, this);
// If the server never responds, FrameLoader won't be able to cancel this load and
// we'll sit here waiting forever. Set a very generous timeout, just in case.
m_timeout.startOneShot(60000, FROM_HERE);
}
void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& response, WebDataConsumerHandle* rawHandle)
{
ASSERT(!response.isNull());
ASSERT(m_state == Initialized);
// |rawHandle|'s ownership is transferred to the callee.
OwnPtr<WebDataConsumerHandle> handle = adoptPtr(rawHandle);
bool isMultipartPayload = response.isMultipartPayload();
bool isValidStateTransition = (m_connectionState == ConnectionStateStarted || m_connectionState == ConnectionStateReceivedResponse);
// In the case of multipart loads, calls to didReceiveData & didReceiveResponse can be interleaved.
RELEASE_ASSERT(isMultipartPayload || isValidStateTransition);
m_connectionState = ConnectionStateReceivedResponse;
const ResourceResponse& resourceResponse = response.toResourceResponse();
if (responseNeedsAccessControlCheck()) {
if (response.wasFetchedViaServiceWorker()) {
if (response.wasFallbackRequiredByServiceWorker()) {
m_loader->cancel();
m_loader.clear();
m_connectionState = ConnectionStateStarted;
m_loader = adoptPtr(Platform::current()->createURLLoader());
ASSERT(m_loader);
ASSERT(!m_request.skipServiceWorker());
m_request.setSkipServiceWorker(true);
WrappedResourceRequest wrappedRequest(m_request);
m_loader->loadAsynchronously(wrappedRequest, this);
return;
}
} else {
// If the response successfully validated a cached resource, perform
// the access control with respect to it. Need to do this right here
// before the resource switches clients over to that validated resource.
Resource* resource = m_resource;
if (!resource->isCacheValidator() || resourceResponse.httpStatusCode() != 304)
m_resource->setResponse(resourceResponse);
if (!m_fetcher->canAccessResource(resource, m_options.securityOrigin.get(), response.url(), ResourceFetcher::ShouldLogAccessControlErrors)) {
m_fetcher->didReceiveResponse(m_resource, resourceResponse);
cancel(ResourceError::cancelledDueToAccessCheckError(KURL(response.url())));
return;
}
}
}
m_resource->responseReceived(resourceResponse, handle.release());
if (m_state == Terminated)
return;
m_fetcher->didReceiveResponse(m_resource, resourceResponse);
if (m_state == Terminated)
return;
if (response.toResourceResponse().isMultipart()) {
// We only support multipart for images, though the image may be loaded
// as a main resource that we end up displaying through an ImageDocument.
if (!m_resource->isImage() && m_resource->type() != Resource::MainResource) {
cancel();
return;
}
m_loadingMultipartContent = true;
} else if (isMultipartPayload) {
// Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
// After the first multipart section is complete, signal to delegates that this load is "finished"
m_fetcher->subresourceLoaderFinishedLoadingOnePart(this);
didFinishLoadingOnePart(0, WebURLLoaderClient::kUnknownEncodedDataLength);
}
if (m_state == Terminated)
return;
if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
return;
m_state = Finishing;
if (!m_notifiedLoadComplete) {
m_notifiedLoadComplete = true;
m_fetcher->didFailLoading(m_resource, ResourceError::cancelledError(m_request.url()));
}
ASSERT(m_state != Terminated);
m_resource->error(Resource::LoadError);
cancel();
}