WebResourceLoadScheduler.cpp [plain text]
#include "config.h"
#include "WebResourceLoadScheduler.h"
#include "Logging.h"
#include "NetworkConnectionToWebProcessMessages.h"
#include "NetworkProcessConnection.h"
#include "NetworkResourceLoadParameters.h"
#include "SessionTracker.h"
#include "WebCoreArgumentCoders.h"
#include "WebErrors.h"
#include "WebFrame.h"
#include "WebFrameLoaderClient.h"
#include "WebPage.h"
#include "WebProcess.h"
#include "WebResourceLoader.h"
#include <WebCore/ApplicationCacheHost.h>
#include <WebCore/CachedResource.h>
#include <WebCore/Document.h>
#include <WebCore/DocumentLoader.h>
#include <WebCore/Frame.h>
#include <WebCore/FrameLoader.h>
#include <WebCore/NetscapePlugInStreamLoader.h>
#include <WebCore/ReferrerPolicy.h>
#include <WebCore/ResourceBuffer.h>
#include <WebCore/ResourceLoader.h>
#include <WebCore/SessionID.h>
#include <WebCore/Settings.h>
#include <WebCore/SubresourceLoader.h>
#include <wtf/text/CString.h>
#if ENABLE(NETWORK_PROCESS)
using namespace WebCore;
namespace WebKit {
WebResourceLoadScheduler::WebResourceLoadScheduler()
: m_internallyFailedLoadTimer(RunLoop::main(), this, &WebResourceLoadScheduler::internallyFailedLoadTimerFired)
, m_suspendPendingRequestsCount(0)
{
}
WebResourceLoadScheduler::~WebResourceLoadScheduler()
{
}
PassRefPtr<SubresourceLoader> WebResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, CachedResource* resource, const ResourceRequest& request, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
{
RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
if (loader)
scheduleLoad(loader.get(), resource, priority, frame->document()->referrerPolicy() == ReferrerPolicyDefault);
return loader.release();
}
PassRefPtr<NetscapePlugInStreamLoader> WebResourceLoadScheduler::schedulePluginStreamLoad(Frame* frame, NetscapePlugInStreamLoaderClient* client, const ResourceRequest& request)
{
RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
if (loader)
scheduleLoad(loader.get(), 0, ResourceLoadPriorityLow, frame->document()->referrerPolicy() == ReferrerPolicyDefault);
return loader.release();
}
void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader, CachedResource* resource, ResourceLoadPriority priority, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
{
ASSERT(resourceLoader);
ASSERT(priority != ResourceLoadPriorityUnresolved);
priority = ResourceLoadPriorityHighest;
ResourceLoadIdentifier identifier = resourceLoader->identifier();
ASSERT(identifier);
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
if (resourceLoader->documentLoader()->scheduleArchiveLoad(resourceLoader, resourceLoader->request())) {
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::scheduleLoad, url '%s' will be handled as an archive resource.", resourceLoader->url().string().utf8().data());
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
return;
}
#endif
if (resourceLoader->documentLoader()->applicationCacheHost()->maybeLoadResource(resourceLoader, resourceLoader->request(), resourceLoader->request().url())) {
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::scheduleLoad, url '%s' will be loaded from application cache.", resourceLoader->url().string().utf8().data());
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
return;
}
#if USE(QUICK_LOOK)
if (maybeLoadQuickLookResource(*resourceLoader)) {
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::scheduleLoad, url '%s' will be handled as a QuickLook resource.", resourceLoader->url().string().utf8().data());
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
return;
}
#endif
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::scheduleLoad, url '%s' will be scheduled with the NetworkProcess with priority %i", resourceLoader->url().string().utf8().data(), priority);
ContentSniffingPolicy contentSniffingPolicy = resourceLoader->shouldSniffContent() ? SniffContent : DoNotSniffContent;
StoredCredentials allowStoredCredentials = resourceLoader->shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
WebFrameLoaderClient* webFrameLoaderClient = toWebFrameLoaderClient(resourceLoader->frameLoader()->client());
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
WebPage* webPage = webFrame ? webFrame->page() : 0;
NetworkResourceLoadParameters loadParameters;
loadParameters.identifier = identifier;
loadParameters.webPageID = webPage ? webPage->pageID() : 0;
loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
loadParameters.sessionID = webPage ? webPage->sessionID() : SessionID::defaultSessionID();
loadParameters.request = resourceLoader->request();
loadParameters.priority = priority;
loadParameters.contentSniffingPolicy = contentSniffingPolicy;
loadParameters.allowStoredCredentials = allowStoredCredentials;
loadParameters.clientCredentialPolicy = (webFrame && webPage) ? resourceLoader->clientCredentialPolicy() : DoNotAskClientForAnyCredentials;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
loadParameters.isMainResource = resource && resource->type() == CachedResource::MainResource;
loadParameters.defersLoading = resourceLoader->defersLoading();
loadParameters.shouldBufferResource = resource && (resource->type() == CachedResource::CSSStyleSheet || resource->type() == CachedResource::Script);
ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials);
if (!WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
scheduleInternallyFailedLoad(resourceLoader);
return;
}
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
notifyDidScheduleResourceRequest(resourceLoader);
}
void WebResourceLoadScheduler::scheduleInternallyFailedLoad(WebCore::ResourceLoader* resourceLoader)
{
m_internallyFailedResourceLoaders.add(resourceLoader);
m_internallyFailedLoadTimer.startOneShot(0);
}
void WebResourceLoadScheduler::internallyFailedLoadTimerFired()
{
Vector<RefPtr<ResourceLoader>> internallyFailedResourceLoaders;
copyToVector(m_internallyFailedResourceLoaders, internallyFailedResourceLoaders);
for (size_t i = 0; i < internallyFailedResourceLoaders.size(); ++i)
internallyFailedResourceLoaders[i]->didFail(internalError(internallyFailedResourceLoaders[i]->url()));
}
void WebResourceLoadScheduler::remove(ResourceLoader* resourceLoader)
{
ASSERT(resourceLoader);
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::remove, url '%s'", resourceLoader->url().string().utf8().data());
if (m_internallyFailedResourceLoaders.contains(resourceLoader)) {
m_internallyFailedResourceLoaders.remove(resourceLoader);
return;
}
ResourceLoadIdentifier identifier = resourceLoader->identifier();
if (!identifier) {
LOG_ERROR("WebResourceLoadScheduler removing a ResourceLoader that has no identifier.");
return;
}
RefPtr<WebResourceLoader> loader = m_webResourceLoaders.take(identifier);
if (!loader)
return;
WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::RemoveLoadIdentifier(identifier), 0);
loader->detachFromCoreLoader();
}
void WebResourceLoadScheduler::setDefersLoading(ResourceLoader* resourceLoader, bool defers)
{
ResourceLoadIdentifier identifier = resourceLoader->identifier();
WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::SetDefersLoading(identifier, defers), 0);
}
void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader*, const URL&)
{
}
void WebResourceLoadScheduler::servePendingRequests(ResourceLoadPriority minimumPriority)
{
LOG(NetworkScheduling, "(WebProcess) WebResourceLoadScheduler::servePendingRequests");
if (m_suspendPendingRequestsCount)
return;
WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ServePendingRequests(minimumPriority), 0);
}
void WebResourceLoadScheduler::suspendPendingRequests()
{
++m_suspendPendingRequestsCount;
}
void WebResourceLoadScheduler::resumePendingRequests()
{
ASSERT(m_suspendPendingRequestsCount);
--m_suspendPendingRequestsCount;
}
void WebResourceLoadScheduler::setSerialLoadingEnabled(bool enabled)
{
WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::SetSerialLoadingEnabled(enabled), Messages::NetworkConnectionToWebProcess::SetSerialLoadingEnabled::Reply(), 0);
}
void WebResourceLoadScheduler::networkProcessCrashed()
{
HashMap<unsigned long, RefPtr<WebResourceLoader>>::iterator end = m_webResourceLoaders.end();
for (HashMap<unsigned long, RefPtr<WebResourceLoader>>::iterator i = m_webResourceLoaders.begin(); i != end; ++i)
scheduleInternallyFailedLoad(i->value.get()->resourceLoader());
m_webResourceLoaders.clear();
}
}
#endif // ENABLE(NETWORK_PROCESS)