void WebFrameLoaderClient::updateGlobalHistoryRedirectLinks()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
DocumentLoader* loader = m_frame->coreFrame()->loader()->documentLoader();
ASSERT(loader->unreachableURL().isEmpty());
// Client redirect
if (!loader->clientRedirectSourceForHistory().isNull()) {
WebProcess::shared().connection()->send(WebProcessProxyMessage::DidPerformClientRedirect,
0,
CoreIPC::In(webPage->pageID(),
loader->clientRedirectSourceForHistory(),
loader->clientRedirectDestinationForHistory(),
m_frame->frameID()));
}
// Server redirect
if (!loader->serverRedirectSourceForHistory().isNull()) {
WebProcess::shared().connection()->send(WebProcessProxyMessage::DidPerformServerRedirect,
0,
CoreIPC::In(webPage->pageID(),
loader->serverRedirectSourceForHistory(),
loader->serverRedirectDestinationForHistory(),
m_frame->frameID()));
}
}
void WebLoaderStrategy::loadResourceSynchronously(NetworkingContext* context, unsigned long resourceLoadIdentifier, const ResourceRequest& request, StoredCredentials storedCredentials, ClientCredentialPolicy clientCredentialPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
{
WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(context);
// FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
// EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
// but in the meantime we have to make sure not to mis-cast.
WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
WebPage* webPage = webFrame ? webFrame->page() : 0;
NetworkResourceLoadParameters loadParameters;
loadParameters.identifier = resourceLoadIdentifier;
loadParameters.webPageID = webPage ? webPage->pageID() : 0;
loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
loadParameters.sessionID = webPage ? webPage->sessionID() : SessionID::defaultSessionID();
loadParameters.request = request;
loadParameters.contentSniffingPolicy = SniffContent;
loadParameters.allowStoredCredentials = storedCredentials;
loadParameters.clientCredentialPolicy = clientCredentialPolicy;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = context->shouldClearReferrerOnHTTPSToHTTPRedirect();
data.resize(0);
HangDetectionDisabler hangDetectionDisabler;
if (!WebProcess::singleton().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, data), 0)) {
response = ResourceResponse();
error = internalError(request.url());
}
}
void CompositingManager::establishConnection(WebPage& webPage, WTF::RunLoop& runLoop)
{
IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
IPC::Connection::Identifier connectionIdentifier(socketPair.server);
IPC::Attachment connectionClientPort(socketPair.client);
m_connection = IPC::Connection::createServerConnection(connectionIdentifier, *this, runLoop);
m_connection->open();
webPage.sendSync(Messages::CompositingManagerProxy::EstablishConnection(connectionClientPort),
Messages::CompositingManagerProxy::EstablishConnection::Reply(), webPage.pageID());
}
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 the DocumentLoader schedules this as an archive resource load,
// then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess.
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;
}
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;
bool privateBrowsingEnabled = resourceLoader->frameLoader()->frame()->settings()->privateBrowsingEnabled();
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(resourceLoader->frameLoader()->client())->webFrame();
WebPage* webPage = webFrame->page();
NetworkResourceLoadParameters loadParameters;
loadParameters.identifier = identifier;
loadParameters.webPageID = webPage->pageID();
loadParameters.webFrameID = webFrame->frameID();
loadParameters.request = resourceLoader->request();
loadParameters.priority = priority;
loadParameters.contentSniffingPolicy = contentSniffingPolicy;
loadParameters.allowStoredCredentials = allowStoredCredentials;
loadParameters.clientCredentialPolicy = resourceLoader->clientCredentialPolicy();
loadParameters.inPrivateBrowsingMode = privateBrowsingEnabled;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
loadParameters.isMainResource = resource && resource->type() == CachedResource::MainResource;
if (!WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
// We probably failed to schedule this load with the NetworkProcess because it had crashed.
// This load will never succeed so we will schedule it to fail asynchronously.
scheduleInternallyFailedLoad(resourceLoader);
return;
}
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
notifyDidScheduleResourceRequest(resourceLoader);
}
void WebFrameLoaderClient::updateGlobalHistory()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
DocumentLoader* loader = m_frame->coreFrame()->loader()->documentLoader();
WebNavigationDataStore data;
data.url = loader->urlForHistory().string();
data.title = loader->title();
WebProcess::shared().connection()->send(WebProcessProxyMessage::DidNavigateWithNavigationData,
0,
CoreIPC::In(webPage->pageID(), data, m_frame->frameID()));
}
PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
{
WebPage* webPage = m_frame->page();
RefPtr<WebFrame> subframe = WebFrame::createSubframe(webPage, name, ownerElement);
// Notify the UI process that subframe has been added.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidCreateSubFrame, webPage->pageID(), CoreIPC::In(subframe->frameID()));
Frame* coreSubframe = subframe->coreFrame();
// The creation of the frame may have run arbitrary JavaScript that removed it from the page already.
m_frame->coreFrame()->loader()->loadURLIntoChildFrame(url, referrer, coreSubframe);
// The frame's onload handler may have removed it from the document.
if (!coreSubframe->tree()->parent())
return 0;
return coreSubframe;
}
void WebFrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState> prpFormState)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// FIXME: Pass more of the form state.
RefPtr<FormState> formState = prpFormState;
HTMLFormElement* form = formState->form();
WebFrame* sourceFrame = static_cast<WebFrameLoaderClient*>(formState->sourceFrame()->loader()->client())->webFrame();
const Vector<std::pair<String, String> >& values = formState->textFieldValues();
RefPtr<APIObject> userData;
webPage->injectedBundleFormClient().willSubmitForm(webPage, form, m_frame, sourceFrame, values, userData);
uint64_t listenerID = m_frame->setUpPolicyListener(function);
WebProcess::shared().connection()->send(WebPageProxyMessage::WillSubmitForm, webPage->pageID(),
CoreIPC::In(m_frame->frameID(), sourceFrame->frameID(), values, listenerID, InjectedBundleUserMessageEncoder(userData.get())));
}
void WebFrameLoaderClient::dispatchDidFinishDocumentLoad()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didFinishDocumentLoadForFrame(webPage, m_frame);
// Notify the UIProcess.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidFinishDocumentLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID()));
}
void WebFrameLoaderClient::setTitle(const String& title, const KURL& url)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
WebProcess::shared().connection()->send(WebProcessProxyMessage::DidUpdateHistoryTitle, 0, CoreIPC::In(webPage->pageID(), title, url.string(), m_frame->frameID()));
}
void WebFrameLoaderClient::updateGlobalHistory()
{
WebPage* webPage = m_frame->page();
if (!webPage || !webPage->pageGroup()->isVisibleToHistoryClient())
return;
DocumentLoader* loader = m_frame->coreFrame()->loader()->documentLoader();
WebNavigationDataStore data;
data.url = loader->urlForHistory().string();
// FIXME: use direction of title.
data.title = loader->title().string();
data.originalRequest = loader->originalRequestCopy();
WebProcess::shared().connection()->send(Messages::WebContext::DidNavigateWithNavigationData(webPage->pageID(), data, m_frame->frameID()), 0);
}
void WebFrameLoaderClient::updateGlobalHistoryRedirectLinks()
{
WebPage* webPage = m_frame->page();
if (!webPage || !webPage->pageGroup()->isVisibleToHistoryClient())
return;
DocumentLoader* loader = m_frame->coreFrame()->loader()->documentLoader();
ASSERT(loader->unreachableURL().isEmpty());
// Client redirect
if (!loader->clientRedirectSourceForHistory().isNull()) {
WebProcess::shared().connection()->send(Messages::WebContext::DidPerformClientRedirect(webPage->pageID(),
loader->clientRedirectSourceForHistory(), loader->clientRedirectDestinationForHistory(), m_frame->frameID()), 0);
}
// Server redirect
if (!loader->serverRedirectSourceForHistory().isNull()) {
WebProcess::shared().connection()->send(Messages::WebContext::DidPerformServerRedirect(webPage->pageID(),
loader->serverRedirectSourceForHistory(), loader->serverRedirectDestinationForHistory(), m_frame->frameID()), 0);
}
}
void WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction& navigationAction, const ResourceRequest& request, PassRefPtr<FormState>, const String& frameName)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
uint64_t listenerID = m_frame->setUpPolicyListener(function);
// FIXME: Pass more than just the navigation action type.
// FIXME: Pass the frame name.
const String& url = request.url().string(); // FIXME: Pass entire request.
uint32_t modifiers = modifiersForNavigationAction(navigationAction);
WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForNewWindowAction, webPage->pageID(),
CoreIPC::In(m_frame->frameID(), (uint32_t)navigationAction.type(), modifiers, url, listenerID));
}
void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& navigationAction, const ResourceRequest& request, PassRefPtr<FormState>)
{
if (m_frame->coreFrame()->loader()->documentLoader()->url().isEmpty() && request.url() == blankURL()) {
// WebKit2 loads initial about:blank documents synchronously, without consulting the policy delegate
ASSERT(m_frame->coreFrame()->loader()->stateMachine()->committingFirstRealLoad());
(m_frame->coreFrame()->loader()->policyChecker()->*function)(PolicyUse);
return;
}
WebPage* webPage = m_frame->page();
if (!webPage)
return;
uint64_t listenerID = m_frame->setUpPolicyListener(function);
// FIXME: Pass more than just the navigation action type.
const String& url = request.url().string(); // FIXME: Pass entire request.
uint32_t modifiers = modifiersForNavigationAction(navigationAction);
WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForNavigationAction, webPage->pageID(),
CoreIPC::In(m_frame->frameID(), (uint32_t)navigationAction.type(), modifiers, url, listenerID));
}
void WebFrameLoaderClient::setTitle(const StringWithDirection& title, const KURL& url)
{
WebPage* webPage = m_frame->page();
if (!webPage || !webPage->pageGroup()->isVisibleToHistoryClient())
return;
// FIXME: use direction of title.
WebProcess::shared().connection()->send(Messages::WebContext::DidUpdateHistoryTitle(webPage->pageID(),
title.string(), url.string(), m_frame->frameID()), 0);
}
void WebFrameLoaderClient::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& MIMEType, const ResourceRequest& request)
{
if (m_frame->coreFrame()->loader()->documentLoader()->url().isEmpty() && request.url() == blankURL()) {
// WebKit2 loads initial about:blank documents synchronously, without consulting the policy delegate
ASSERT(m_frame->coreFrame()->loader()->stateMachine()->committingFirstRealLoad());
(m_frame->coreFrame()->loader()->policyChecker()->*function)(PolicyUse);
return;
}
WebPage* webPage = m_frame->page();
if (!webPage)
return;
uint64_t listenerID = m_frame->setUpPolicyListener(function);
const String& url = request.url().string(); // FIXME: Pass entire request.
WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForMIMEType, webPage->pageID(),
CoreIPC::In(m_frame->frameID(), MIMEType, url, listenerID));
}
void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader, CachedResource* resource, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
{
ASSERT(resourceLoader);
ResourceLoadIdentifier identifier = resourceLoader->identifier();
ASSERT(identifier);
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
// If the DocumentLoader schedules this as an archive resource load,
// then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess.
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(), resourceLoader->request().priority());
ContentSniffingPolicy contentSniffingPolicy = resourceLoader->shouldSniffContent() ? SniffContent : DoNotSniffContent;
StoredCredentials allowStoredCredentials = resourceLoader->shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
// FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
// EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
// but in the meantime we have to make sure not to mis-cast.
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.contentSniffingPolicy = contentSniffingPolicy;
loadParameters.allowStoredCredentials = allowStoredCredentials;
// If there is no WebFrame then this resource cannot be authenticated with the client.
loadParameters.clientCredentialPolicy = (webFrame && webPage) ? resourceLoader->clientCredentialPolicy() : DoNotAskClientForAnyCredentials;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
loadParameters.isMainResource = resource && resource->type() == CachedResource::MainResource;
loadParameters.defersLoading = resourceLoader->defersLoading();
loadParameters.needsCertificateInfo = loadParameters.isMainResource;
loadParameters.maximumBufferingTime = maximumBufferingTime(resource);
ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials);
if (!WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
// We probably failed to schedule this load with the NetworkProcess because it had crashed.
// This load will never succeed so we will schedule it to fail asynchronously.
scheduleInternallyFailedLoad(resourceLoader);
return;
}
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
notifyDidScheduleResourceRequest(resourceLoader);
}
void EventDispatcher::getQueuedTouchEventsForPage(const WebPage& webPage, TouchEventQueue& destinationQueue)
{
LockHolder locker(&m_touchEventsLock);
destinationQueue = m_touchEvents.take(webPage.pageID());
}
void WebFrameLoaderClient::dispatchDidFailProvisionalLoad(const ResourceError& error)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didFailProvisionalLoadWithErrorForFrame(webPage, m_frame);
// Notify the UIProcess.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidFailProvisionalLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID()));
// If we have a load listener, notify it.
if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
loadListener->didFailLoad(m_frame, error.isCancellation());
}
void WebFrameLoaderClient::dispatchDidReceiveTitle(const String& title)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didReceiveTitleForFrame(webPage, title, m_frame);
// Notify the UIProcess.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveTitleForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), title));
}
void WebFrameLoaderClient::dispatchDidStartProvisionalLoad()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
DocumentLoader* provisionalLoader = m_frame->coreFrame()->loader()->provisionalDocumentLoader();
const String& url = provisionalLoader->url().string();
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didStartProvisionalLoadForFrame(webPage, m_frame);
// Notify the UIProcess.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidStartProvisionalLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), url));
}
// WebCore::UserMessageHandlerDescriptor
void didPostMessage(WebCore::UserMessageHandler& handler, WebCore::SerializedScriptValue* value) override
{
WebCore::Frame* frame = handler.frame();
if (!frame)
return;
WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
if (!webFrame)
return;
WebPage* webPage = webFrame->page();
if (!webPage)
return;
WebProcess::singleton().parentProcessConnection()->send(Messages::WebUserContentControllerProxy::DidPostMessage(webPage->pageID(), webFrame->frameID(), SecurityOriginData::fromFrame(frame), m_identifier, IPC::DataReference(value->data())), m_controller->identifier());
}
void WebLoaderStrategy::scheduleLoad(ResourceLoader* resourceLoader, CachedResource* resource, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
{
ASSERT(resourceLoader);
ResourceLoadIdentifier identifier = resourceLoader->identifier();
ASSERT(identifier);
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
// If the DocumentLoader schedules this as an archive resource load,
// then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess.
if (resourceLoader->documentLoader()->scheduleArchiveLoad(resourceLoader, resourceLoader->request())) {
LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::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) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded from application cache.", resourceLoader->url().string().utf8().data());
m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader));
return;
}
if (resourceLoader->request().url().protocolIsData()) {
LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded as data.", resourceLoader->url().string().utf8().data());
startLocalLoad(*resourceLoader);
return;
}
#if USE(QUICK_LOOK)
if (resourceLoader->request().url().protocolIs(QLPreviewProtocol())) {
LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a QuickLook resource.", resourceLoader->url().string().utf8().data());
startLocalLoad(*resourceLoader);
return;
}
#endif
#if USE(SOUP)
// For apps that call g_resource_load in a web extension.
// https://blogs.gnome.org/alexl/2012/01/26/resources-in-glib/
if (resourceLoader->request().url().protocolIs("resource")) {
LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a GResource.", resourceLoader->url().string().utf8().data());
startLocalLoad(*resourceLoader);
return;
}
#endif
LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be scheduled with the NetworkProcess with priority %d", resourceLoader->url().string().latin1().data(), static_cast<int>(resourceLoader->request().priority()));
ContentSniffingPolicy contentSniffingPolicy = resourceLoader->shouldSniffContent() ? SniffContent : DoNotSniffContent;
StoredCredentials allowStoredCredentials = resourceLoader->shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
// FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
// EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
// but in the meantime we have to make sure not to mis-cast.
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.contentSniffingPolicy = contentSniffingPolicy;
loadParameters.allowStoredCredentials = allowStoredCredentials;
// If there is no WebFrame then this resource cannot be authenticated with the client.
loadParameters.clientCredentialPolicy = (webFrame && webPage && resourceLoader->isAllowedToAskUserForCredentials()) ? AskClientForAllCredentials : DoNotAskClientForAnyCredentials;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
loadParameters.defersLoading = resourceLoader->defersLoading();
loadParameters.needsCertificateInfo = resourceLoader->shouldIncludeCertificateInfo();
loadParameters.maximumBufferingTime = maximumBufferingTime(resource);
ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials);
if (!WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
WEBLOADERSTRATEGY_LOG_ALWAYS_ERROR("WebLoaderStrategy::scheduleLoad: Unable to schedule resource with the NetworkProcess with priority = %d, pageID = %llu, frameID = %llu", static_cast<int>(resourceLoader->request().priority()), static_cast<unsigned long long>(loadParameters.webPageID), static_cast<unsigned long long>(loadParameters.webFrameID));
// We probably failed to schedule this load with the NetworkProcess because it had crashed.
// This load will never succeed so we will schedule it to fail asynchronously.
scheduleInternallyFailedLoad(resourceLoader);
return;
}
auto webResourceLoader = WebResourceLoader::create(resourceLoader);
WEBLOADERSTRATEGY_LOG_ALWAYS("WebLoaderStrategy::scheduleLoad: Resource will be scheduled with the NetworkProcess with priority = %d, pageID = %llu, frameID = %llu, WebResourceLoader = %p", static_cast<int>(resourceLoader->request().priority()), static_cast<unsigned long long>(loadParameters.webPageID), static_cast<unsigned long long>(loadParameters.webFrameID), webResourceLoader.ptr());
m_webResourceLoaders.set(identifier, WTFMove(webResourceLoader));
}
void EventDispatcher::clearQueuedTouchEventsForPage(const WebPage& webPage)
{
LockHolder locker(&m_touchEventsLock);
m_touchEvents.remove(webPage.pageID());
}
void WebFrameLoaderClient::dispatchDidFinishLoad()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didFinishLoadForFrame(webPage, m_frame);
// Notify the UIProcess.
WebProcess::shared().connection()->send(WebPageProxyMessage::DidFinishLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID()));
// If we have a load listener, notify it.
if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
loadListener->didFinishLoad(m_frame);
}
void VisitedLinkTableController::addVisitedLink(Page& page, LinkHash linkHash)
{
if (m_visitedLinkTable.isLinkVisited(linkHash))
return;
WebPage* webPage = WebPage::fromCorePage(&page);
if (!webPage)
return;
WebProcess::singleton().parentProcessConnection()->send(Messages::VisitedLinkProvider::AddVisitedLinkHashFromPage(webPage->pageID(), linkHash), m_identifier);
}
void WebFrameLoaderClient::dispatchDidFirstVisuallyNonEmptyLayout()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
WebProcess::shared().connection()->send(WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID()));
}