bool MainResourceLoader::loadNow(ResourceRequest& r)
{
bool shouldLoadEmptyBeforeRedirect = shouldLoadAsEmptyDocument(r.url());
ASSERT(!m_handle);
ASSERT(shouldLoadEmptyBeforeRedirect || !defersLoading());
// Send this synthetic delegate callback since clients expect it, and
// we no longer send the callback from within NSURLConnection for
// initial requests.
willSendRequest(r, ResourceResponse());
ASSERT(!deletionHasBegun());
// <rdar://problem/4801066>
// willSendRequest() is liable to make the call to frameLoader() return NULL, so we need to check that here
if (!frameLoader())
return false;
const KURL& url = r.url();
bool shouldLoadEmpty = shouldLoadAsEmptyDocument(url) && !m_substituteData.isValid();
if (shouldLoadEmptyBeforeRedirect && !shouldLoadEmpty && defersLoading())
return true;
resourceLoadScheduler()->addMainResourceLoad(this);
if (m_substituteData.isValid())
handleSubstituteDataLoadSoon(r);
else if (shouldLoadEmpty || frameLoader()->client()->representationExistsForURLScheme(url.protocol()))
handleEmptyLoad(url, !shouldLoadEmpty);
else
m_handle = ResourceHandle::create(m_frame->loader()->networkingContext(), r, this, false, true);
return false;
}
void ResourceLoader::releaseResources()
{
ASSERT(!m_reachedTerminalState);
// It's possible that when we release the handle, it will be
// deallocated and release the last reference to this object.
// We need to retain to avoid accessing the object after it
// has been deallocated and also to avoid reentering this method.
RefPtr<ResourceLoader> protector(this);
m_frame = 0;
m_documentLoader = 0;
// We need to set reachedTerminalState to true before we release
// the resources to prevent a double dealloc of WebView <rdar://problem/4372628>
m_reachedTerminalState = true;
m_identifier = 0;
resourceLoadScheduler()->remove(this);
if (m_handle) {
// Clear out the ResourceHandle's client so that it doesn't try to call
// us back after we release it, unless it has been replaced by someone else.
if (m_handle->client() == this)
m_handle->setClient(0);
m_handle = 0;
}
m_resourceData = 0;
m_deferredRequest = ResourceRequest();
}
void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
{
// Protect this in this delegate method since the additional processing can do
// anything including possibly derefing this; one example of this is Radar 3266216.
RefPtr<ResourceLoader> protector(this);
ASSERT(!m_reachedTerminalState);
if (m_options.sendLoadCallbacks == SendCallbacks) {
if (!m_identifier) {
m_identifier = m_frame->page()->progress()->createUniqueIdentifier();
frameLoader()->notifier()->assignIdentifierToInitialRequest(m_identifier, documentLoader(), request);
}
frameLoader()->notifier()->willSendRequest(this, request, redirectResponse);
}
if (!redirectResponse.isNull()) {
#if USE(PLATFORM_STRATEGIES)
platformStrategies()->loaderStrategy()->resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url());
#else
resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url());
#endif
}
m_request = request;
if (!redirectResponse.isNull() && !m_documentLoader->isCommitted())
frameLoader()->client()->dispatchDidReceiveServerRedirectForProvisionalLoad();
}
void IconLoader::startLoading()
{
if (m_resourceLoader)
return;
// Set flag so we can detect the case where the load completes before
// SubresourceLoader::create returns.
m_loadIsInProgress = true;
ResourceRequest resourceRequest(m_frame->loader()->iconURL());
resourceRequest.setPriority(ResourceLoadPriorityLow);
// SAMSUNG CHANGE : not sending favicon request once 404 not found error received for the favicon.
m_iconUrl = m_frame->loader()->iconURL();
// SAMSUNG CHANGE
RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_frame, this, resourceRequest);
if (!loader)
LOG_ERROR("Failed to start load for icon at url %s", m_frame->loader()->iconURL().string().ascii().data());
// Store the handle so we can cancel the load if stopLoading is called later.
// But only do it if the load hasn't already completed.
if (m_loadIsInProgress)
m_resourceLoader = loader.release();
}
void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
{
if (!fastMallocSize(documentLoader()->applicationCacheHost()))
CRASH();
if (!fastMallocSize(documentLoader()->frame()))
CRASH();
// Protect this in this delegate method since the additional processing can do
// anything including possibly derefing this; one example of this is Radar 3266216.
RefPtr<ResourceLoader> protector(this);
ASSERT(!m_reachedTerminalState);
if (m_options.sendLoadCallbacks == SendCallbacks) {
if (!m_identifier) {
m_identifier = m_frame->page()->progress()->createUniqueIdentifier();
frameLoader()->notifier()->assignIdentifierToInitialRequest(m_identifier, documentLoader(), request);
}
frameLoader()->notifier()->willSendRequest(this, request, redirectResponse);
}
if (!redirectResponse.isNull())
resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url());
m_request = request;
}
void PluginView::Stream::start()
{
ASSERT(!m_loader);
Frame* frame = m_pluginView->m_pluginElement->document()->frame();
ASSERT(frame);
m_loader = resourceLoadScheduler()->schedulePluginStreamLoad(frame, this, m_request);
}
void CachedResourceLoader::performPostLoadActions()
{
checkForPendingPreloads();
#if USE(PLATFORM_STRATEGIES)
platformStrategies()->loaderStrategy()->resourceLoadScheduler()->servePendingRequests();
#else
resourceLoadScheduler()->servePendingRequests();
#endif
}
void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, SecurityCheckPolicy securityCheck)
{
// Any credential should have been removed from the cross-site requests.
const KURL& requestURL = request.url();
ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
if (m_async) {
// Don't sniff content or send load callbacks for the preflight request.
bool sendLoadCallbacks = m_options.sendLoadCallbacks && !m_actualRequest;
bool sniffContent = m_options.sniffContent && !m_actualRequest;
// Keep buffering the data for the preflight request.
bool shouldBufferData = m_options.shouldBufferData || m_actualRequest;
// Clear the loader so that any callbacks from SubresourceLoader::create will not have the old loader.
m_loader = 0;
m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, securityCheck, sendLoadCallbacks,
sniffContent, m_optionalOutgoingReferrer, shouldBufferData);
return;
}
// FIXME: ThreadableLoaderOptions.sniffContent is not supported for synchronous requests.
StoredCredentials storedCredentials = m_options.allowCredentials ? AllowStoredCredentials : DoNotAllowStoredCredentials;
Vector<char> data;
ResourceError error;
ResourceResponse response;
unsigned long identifier = std::numeric_limits<unsigned long>::max();
if (m_document->frame())
identifier = m_document->frame()->loader()->loadResourceSynchronously(request, storedCredentials, error, response, data);
// No exception for file:/// resources, see <rdar://problem/4962298>.
// Also, if we have an HTTP response, then it wasn't a network error in fact.
if (!error.isNull() && !requestURL.isLocalFile() && response.httpStatusCode() <= 0) {
m_client->didFail(error);
return;
}
// FIXME: FrameLoader::loadSynchronously() does not tell us whether a redirect happened or not, so we guess by comparing the
// request and response URLs. This isn't a perfect test though, since a server can serve a redirect to the same URL that was
// requested. Also comparing the request and response URLs as strings will fail if the requestURL still has its credentials.
if (requestURL != response.url() && !isAllowedRedirect(response.url())) {
m_client->didFailRedirectCheck();
return;
}
didReceiveResponse(0, response);
const char* bytes = static_cast<const char*>(data.data());
int len = static_cast<int>(data.size());
didReceiveData(0, bytes, len);
didFinishLoading(identifier, 0.0);
}
PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, bool incremental, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
{
OwnPtr<CachedResourceRequest> request = adoptPtr(new CachedResourceRequest(cachedResourceLoader, resource, incremental));
ResourceRequest resourceRequest = resource->resourceRequest();
#if PLATFORM(CHROMIUM)
resourceRequest.setTargetType(cachedResourceTypeToTargetType(resource->type()));
#endif
if (!resource->accept().isEmpty())
resourceRequest.setHTTPAccept(resource->accept());
if (resource->isCacheValidator()) {
CachedResource* resourceToRevalidate = resource->resourceToRevalidate();
ASSERT(resourceToRevalidate->canUseCacheValidator());
ASSERT(resourceToRevalidate->isLoaded());
const String& lastModified = resourceToRevalidate->response().httpHeaderField("Last-Modified");
const String& eTag = resourceToRevalidate->response().httpHeaderField("ETag");
if (!lastModified.isEmpty() || !eTag.isEmpty()) {
ASSERT(cachedResourceLoader->cachePolicy() != CachePolicyReload);
if (cachedResourceLoader->cachePolicy() == CachePolicyRevalidate)
resourceRequest.setHTTPHeaderField("Cache-Control", "max-age=0");
if (!lastModified.isEmpty())
resourceRequest.setHTTPHeaderField("If-Modified-Since", lastModified);
if (!eTag.isEmpty())
resourceRequest.setHTTPHeaderField("If-None-Match", eTag);
}
}
#if ENABLE(LINK_PREFETCH)
if (resource->type() == CachedResource::LinkPrefetch || resource->type() == CachedResource::LinkPrerender || resource->type() == CachedResource::LinkSubresource)
resourceRequest.setHTTPHeaderField("Purpose", "prefetch");
#endif
ResourceLoadPriority priority = resource->loadPriority();
resourceRequest.setPriority(priority);
RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(cachedResourceLoader->document()->frame(), request.get(), resourceRequest, priority, securityCheck, options);
if (!loader || loader->reachedTerminalState()) {
// FIXME: What if resources in other frames were waiting for this revalidation?
LOG(ResourceLoading, "Cannot start loading '%s'", resource->url().string().latin1().data());
if (resource->resourceToRevalidate())
memoryCache()->revalidationFailed(resource);
resource->error(CachedResource::LoadError);
//+EAWebKitChange
//10/19/2012
return PassOwnPtr<CachedResourceRequest>(std::nullptr_t()) ;
//-EAWebKitChange
}
request->m_loader = loader;
return request.release();
}
void ResourceLoader::releaseResources() {
m_frame = 0;
m_documentLoader = 0;
m_identifier = 0;
resourceLoadScheduler()->remove(this);
m_handle->setClient(0);
m_resourceData = 0;
m_deferredRequest = ResourceRequest();
}
void ContainerNode::resumePostAttachCallbacks()
{
if (s_attachDepth == 1) {
RefPtr<ContainerNode> protect(this);
if (s_postAttachCallbackQueue)
dispatchPostAttachCallbacks();
if (s_shouldReEnableMemoryCacheCallsAfterAttach) {
s_shouldReEnableMemoryCacheCallsAfterAttach = false;
if (Page* page = document()->page())
page->setMemoryCacheClientCallsEnabled(true);
}
resourceLoadScheduler()->resumePendingRequests();
}
--s_attachDepth;
}
void ContainerNode::suspendPostAttachCallbacks()
{
if (!s_attachDepth) {
ASSERT(!s_shouldReEnableMemoryCacheCallsAfterAttach);
if (Page* page = document()->page()) {
// FIXME: How can this call be specific to one Page, while the
// s_attachDepth is a global? Doesn't make sense.
if (page->areMemoryCacheClientCallsEnabled()) {
page->setMemoryCacheClientCallsEnabled(false);
s_shouldReEnableMemoryCacheCallsAfterAttach = true;
}
}
resourceLoadScheduler()->suspendPendingRequests();
}
++s_attachDepth;
}
void MainResourceLoader::loadNow(ResourceRequest& r)
{
ASSERT(!m_handle);
ASSERT(!defersLoading());
#if USE(PLATFORM_STRATEGIES)
platformStrategies()->loaderStrategy()->resourceLoadScheduler()->addMainResourceLoad(this);
#else
resourceLoadScheduler()->addMainResourceLoad(this);
#endif
if (m_substituteData.isValid())
handleSubstituteDataLoadSoon(r);
else
m_handle = ResourceHandle::create(m_frame->loader()->networkingContext(), r, this, false, true);
return;
}
void CachedResourceLoader::performPostLoadActions()
{
checkForPendingPreloads();
resourceLoadScheduler()->servePendingRequests();
}
void PluginStream::start()
{
ASSERT(!m_loadManually);
m_loader = resourceLoadScheduler()->schedulePluginStreamLoad(m_frame, this, m_resourceRequest);
}
bool ResourceLoadScheduler::HostInformation::limitRequests(ResourceLoadPriority priority) const
{
if (priority == ResourceLoadPriorityVeryLow && !m_requestsLoading.isEmpty())
return true;
return m_requestsLoading.size() >= (resourceLoadScheduler()->isSerialLoadingEnabled() ? 1 : m_maxRequestsInFlight);
}