bool WebInspectorClient::sendMessageToFrontend(const String& message)
{
WebInspector* inspector = m_page->inspector();
if (!inspector)
return false;
#if ENABLE(INSPECTOR_SERVER)
if (inspector->hasRemoteFrontendConnected()) {
inspector->sendMessageToRemoteFrontend(message);
return true;
}
#endif
WebPage* inspectorPage = inspector->inspectorPage();
if (inspectorPage)
return doDispatchMessageOnFrontendPage(inspectorPage->corePage(), message);
return false;
}
void WebProcess::setTextCheckerState(const TextCheckerState& textCheckerState)
{
bool continuousSpellCheckingTurnedOff = !textCheckerState.isContinuousSpellCheckingEnabled && m_textCheckerState.isContinuousSpellCheckingEnabled;
bool grammarCheckingTurnedOff = !textCheckerState.isGrammarCheckingEnabled && m_textCheckerState.isGrammarCheckingEnabled;
m_textCheckerState = textCheckerState;
if (!continuousSpellCheckingTurnedOff && !grammarCheckingTurnedOff)
return;
HashMap<uint64_t, RefPtr<WebPage> >::iterator end = m_pageMap.end();
for (HashMap<uint64_t, RefPtr<WebPage> >::iterator it = m_pageMap.begin(); it != end; ++it) {
WebPage* page = (*it).value.get();
if (continuousSpellCheckingTurnedOff)
page->unmarkAllMisspellings();
if (grammarCheckingTurnedOff)
page->unmarkAllBadGrammar();
}
}
WebView::WebView(QWidget *parent, CookieJar *cookieJar) :
QWebView(parent),
cookieJar(cookieJar)
{
WebPage *page = new WebPage();
page->setView(this);
this->setPage(page);
settings()->setAttribute(QWebSettings::JavascriptEnabled, true);
settings()->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);
settings()->setAttribute(QWebSettings::JavascriptCanAccessClipboard, true);
settings()->setAttribute(QWebSettings::JavascriptCanCloseWindows, true);
settings()->setAttribute(QWebSettings::NotificationsEnabled, true);
settings()->setThirdPartyCookiePolicy(QWebSettings::ThirdPartyCookiePolicy::AlwaysAllowThirdPartyCookies);
settings()->setFontFamily(QWebSettings::StandardFont, "Segoe UI");
settings()->setFontSize(QWebSettings::DefaultFontSize, 16);
setContextMenuPolicy(Qt::ContextMenuPolicy::PreventContextMenu);
setStoragePath();
setCookies();
}
bool WebFrameLoaderClient::shouldGoToHistoryItem(HistoryItem* item) const
{
WebPage* webPage = m_frame->page();
if (!webPage)
return false;
uint64_t itemID = WebBackForwardListProxy::idForItem(item);
if (!itemID) {
// We should never be considering navigating to an item that is not actually in the back/forward list.
ASSERT_NOT_REACHED();
return false;
}
bool shouldGoToBackForwardListItem;
if (!webPage->sendSync(Messages::WebPageProxy::ShouldGoToBackForwardListItem(itemID), Messages::WebPageProxy::ShouldGoToBackForwardListItem::Reply(shouldGoToBackForwardListItem)))
return false;
return shouldGoToBackForwardListItem;
}
QNetworkReply* AdBlockManager::block(const QNetworkRequest &request)
{
#ifdef ADBLOCK_DEBUG
QElapsedTimer timer;
timer.start();
#endif
const QString urlString = request.url().toEncoded().toLower();
const QString urlDomain = request.url().host().toLower();
const QString urlScheme = request.url().scheme().toLower();
if (!isEnabled() || !canRunOnScheme(urlScheme))
return 0;
const AdBlockRule* blockedRule = m_matcher->match(request, urlDomain, urlString);
if (blockedRule) {
QVariant v = request.attribute((QNetworkRequest::Attribute)(QNetworkRequest::User + 100));
WebPage* webPage = static_cast<WebPage*>(v.value<void*>());
if (webPage) {
if (!canBeBlocked(webPage->url())) {
return 0;
}
webPage->addAdBlockRule(blockedRule, request.url());
}
AdBlockBlockedNetworkReply* reply = new AdBlockBlockedNetworkReply(blockedRule, this);
reply->setRequest(request);
#ifdef ADBLOCK_DEBUG
qDebug() << "BLOCKED: " << timer.elapsed() << blockedRule->filter() << request.url();
#endif
return reply;
}
#ifdef ADBLOCK_DEBUG
qDebug() << timer.elapsed() << request.url();
#endif
return 0;
}
void QtNetworkAccessManager::onSslErrors(QNetworkReply* reply, const QList<QSslError>& qSslErrors)
{
#ifndef QT_NO_SSL
WebPage* webPage = obtainOriginatingWebPage(reply->request());
// FIXME: This check can go away once our Qt version is up-to-date. See: QTBUG-23512.
if (!webPage)
return;
String hostname = reply->url().host();
bool ignoreErrors = false;
if (webPage->sendSync(
Messages::WebPageProxy::CertificateVerificationRequest(hostname),
Messages::WebPageProxy::CertificateVerificationRequest::Reply(ignoreErrors))) {
if (ignoreErrors)
reply->ignoreSslErrors(qSslErrors);
}
#endif
}
void WebPageManager::reset() {
m_timeout = -1;
m_cookieJar->clearCookies();
m_networkAccessManager->reset();
m_customHeadersRequestHandler->reset();
m_currentPage->resetLocalStorage();
m_blacklistedRequestHandler->reset();
m_unknownUrlHandler->reset();
while (!m_pages.isEmpty()) {
WebPage *page = m_pages.takeFirst();
page->deleteLater();
}
qint64 size = QWebSettings::offlineWebApplicationCacheQuota();
// No public function was found to wrap the empty() call to
// WebCore::cacheStorage().empty()
QWebSettings::setOfflineWebApplicationCacheQuota(size);
createPage()->setFocus();
}
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::dispatchDidFailProvisionalLoad(const ResourceError& error)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
RefPtr<APIObject> userData;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didFailProvisionalLoadWithErrorForFrame(webPage, m_frame, error, userData);
webPage->sandboxExtensionTracker().didFailProvisionalLoad(m_frame);
// Notify the UIProcess.
webPage->send(Messages::WebPageProxy::DidFailProvisionalLoadForFrame(m_frame->frameID(), error, InjectedBundleUserMessageEncoder(userData.get())));
// If we have a load listener, notify it.
if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
loadListener->didFailLoad(m_frame, error.isCancellation());
}
void NetworkManager::setSSLConfiguration(QNetworkReply* reply)
{
if (!reply->sslConfiguration().isNull()) {
QSslCertificate cert = reply->sslConfiguration().peerCertificate();
if (!cert.isValid() || reply->property("downReply").toBool()) {
return;
}
QNetworkRequest request = reply->request();
QVariant v = request.attribute((QNetworkRequest::Attribute)(QNetworkRequest::User + 100));
WebPage* webPage = static_cast<WebPage*>(v.value<void*>());
if (!webPage) {
return;
}
if (webPage->url().host() == reply->url().host()) {
webPage->setSSLCertificate(cert);
}
}
}
void WebLoaderStrategy::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, bool shouldUseCredentialStorage)
{
// It's possible that call to createPingHandle might be made during initial empty Document creation before a NetworkingContext exists.
// It is not clear that we should send ping loads during that process anyways.
if (!networkingContext)
return;
WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(networkingContext);
WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
WebPage* webPage = webFrame ? webFrame->page() : nullptr;
NetworkResourceLoadParameters loadParameters;
loadParameters.request = request;
loadParameters.sessionID = webPage ? webPage->sessionID() : SessionID::defaultSessionID();
loadParameters.allowStoredCredentials = shouldUseCredentialStorage ? AllowStoredCredentials : DoNotAllowStoredCredentials;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = networkingContext->shouldClearReferrerOnHTTPSToHTTPRedirect();
WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::LoadPing(loadParameters), 0);
}
WebPage
WebPage::operator< (const WebPage & w)
{
if (filename () < w.filename ()) //compare webpages by their filenames
return *this;
else
return w;
}
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::dispatchDidStartProvisionalLoad()
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
webPage->findController().hideFindUI();
webPage->sandboxExtensionTracker().didStartProvisionalLoad(m_frame);
DocumentLoader* provisionalLoader = m_frame->coreFrame()->loader()->provisionalDocumentLoader();
const String& url = provisionalLoader->url().string();
RefPtr<APIObject> userData;
// Notify the bundle client.
webPage->injectedBundleLoaderClient().didStartProvisionalLoadForFrame(webPage, m_frame, userData);
String unreachableURL = provisionalLoader->unreachableURL().string();
// Notify the UIProcess.
webPage->send(Messages::WebPageProxy::DidStartProvisionalLoadForFrame(m_frame->frameID(), url, unreachableURL, InjectedBundleUserMessageEncoder(userData.get())));
}
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 DisplayWindow::clear_display()
{
if (progress_bar)
{
mainwindow->remove_widget_from_layout(progress_bar);
delete progress_bar;
progress_bar = NULL;
}
if (web_view)
{
mainwindow->remove_widget_from_layout(web_view);
#if defined(WEB_MACHINE_ENGINE)
WebPage* page = (WebPage*)web_view->page();
QWebChannel *channel = page ? page->webChannel() : NULL;
if (channel)
channel->deregisterObject(page);
#endif
delete web_view;
web_view = NULL;
}
}
void DownloadManager::closeDownloadTab(const QUrl &url) const
{
// Attempt to close empty tab that was opened only for loading the download url
auto testWebView = [](TabbedWebView *view, const QUrl &url) {
if (view->browserWindow()->tabWidget()->tabBar()->normalTabsCount() < 2) {
return false;
}
WebPage *page = view->page();
if (page->history()->count() != 0) {
return false;
}
if (page->url() != QUrl()) {
return false;
}
QUrl tabUrl = page->requestedUrl();
if (tabUrl.isEmpty()) {
tabUrl = QUrl(view->webTab()->locationBar()->text());
}
return tabUrl.host() == url.host();
};
if (testWebView(mApp->getWindow()->weView(), url)) {
mApp->getWindow()->weView()->closeView();
return;
}
const auto windows = mApp->windows();
for (auto *window : windows) {
const auto tabs = window->tabWidget()->allTabs();
for (auto *tab : tabs) {
auto *view = tab->webView();
if (testWebView(view, url)) {
view->closeView();
return;
}
}
}
}
void QtNetworkAccessManager::onAuthenticationRequired(QNetworkReply* reply, QAuthenticator* authenticator)
{
WebPage* webPage = obtainOriginatingWebPage(reply->request());
// FIXME: This check can go away once our Qt version is up-to-date. See: QTBUG-23512.
if (!webPage)
return;
String hostname = reply->url().toString(QUrl::RemovePath | QUrl::RemoveQuery | QUrl::RemoveFragment | QUrl::StripTrailingSlash);
String realm = authenticator->realm();
String prefilledUsername = authenticator->user();
String username;
String password;
if (webPage->sendSync(
Messages::WebPageProxy::AuthenticationRequiredRequest(hostname, realm, prefilledUsername),
Messages::WebPageProxy::AuthenticationRequiredRequest::Reply(username, password))) {
if (!username.isEmpty())
authenticator->setUser(username);
if (!password.isEmpty())
authenticator->setPassword(password);
}
}
void WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction& navigationAction, const ResourceRequest& request, PassRefPtr<FormState> formState, const String& frameName)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
RefPtr<APIObject> userData;
RefPtr<InjectedBundleNavigationAction> action = InjectedBundleNavigationAction::create(m_frame, navigationAction, formState);
// Notify the bundle client.
WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNewWindowAction(webPage, m_frame, action.get(), request, frameName, userData);
if (policy == WKBundlePagePolicyActionUse) {
(m_frame->coreFrame()->loader()->policyChecker()->*function)(PolicyUse);
return;
}
uint64_t listenerID = m_frame->setUpPolicyListener(function);
// Notify the UIProcess.
webPage->send(Messages::WebPageProxy::DecidePolicyForNewWindowAction(m_frame->frameID(), action->navigationType(), action->modifiers(), action->mouseButton(), request, frameName, listenerID, InjectedBundleUserMessageEncoder(userData.get())));
}
void WebFrameLoaderClient::finishedLoading(DocumentLoader* loader)
{
if (!m_pluginView) {
committedLoad(loader, 0, 0);
if (m_frameHasCustomRepresentation) {
WebPage* webPage = m_frame->page();
if (!webPage)
return;
RefPtr<SharedBuffer> mainResourceData = loader->mainResourceData();
CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(mainResourceData ? mainResourceData->data() : 0), mainResourceData ? mainResourceData->size() : 0);
webPage->send(Messages::WebPageProxy::DidFinishLoadingDataForCustomRepresentation(loader->response().suggestedFilename(), dataReference));
}
return;
}
m_pluginView->manualLoadDidFinishLoading();
m_pluginView = 0;
m_hasSentResponseToPluginView = false;
}
QNetworkReply* AdBlockNetwork::block(const QNetworkRequest &request)
{
const QString &urlString = request.url().toEncoded();
const QString &urlScheme = request.url().scheme();
if (urlScheme == "data" || urlScheme == "qrc" || urlScheme == "file" || urlScheme == "qupzilla") {
return 0;
}
AdBlockManager* manager = AdBlockManager::instance();
if (!manager->isEnabled()) {
return 0;
}
const AdBlockRule* blockedRule = 0;
AdBlockSubscription* subscription = manager->subscription();
if (subscription->allow(urlString)) {
return 0;
}
if (const AdBlockRule* rule = subscription->block(urlString)) {
blockedRule = rule;
}
if (blockedRule) {
QVariant v = request.attribute((QNetworkRequest::Attribute)(QNetworkRequest::User + 100));
WebPage* webPage = static_cast<WebPage*>(v.value<void*>());
if (WebPage::isPointerSafeToUse(webPage)) {
webPage->addAdBlockRule(blockedRule->filter(), request.url());
}
AdBlockBlockedNetworkReply* reply = new AdBlockBlockedNetworkReply(request, blockedRule, this);
return reply;
}
return 0;
}
void QtNetworkAccessManager::onProxyAuthenticationRequired(const QNetworkProxy& proxy, QAuthenticator* authenticator)
{
// FIXME: Check if there is a better way to get a reference to the page.
WebPage* webPage = m_webProcess->focusedWebPage();
if (!webPage)
return;
String hostname = proxy.hostName();
uint16_t port = static_cast<uint16_t>(proxy.port());
String prefilledUsername = authenticator->user();
String username;
String password;
if (webPage->sendSync(
Messages::WebPageProxy::ProxyAuthenticationRequiredRequest(hostname, port, prefilledUsername),
Messages::WebPageProxy::ProxyAuthenticationRequiredRequest::Reply(username, password))) {
if (!username.isEmpty())
authenticator->setUser(username);
if (!password.isEmpty())
authenticator->setPassword(password);
}
}
void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& navigationAction, const ResourceRequest& request, PassRefPtr<FormState> formState)
{
WebPage* webPage = m_frame->page();
if (!webPage)
return;
// Always ignore requests with empty URLs.
if (request.isEmpty()) {
(m_frame->coreFrame()->loader()->policyChecker()->*function)(PolicyIgnore);
return;
}
RefPtr<APIObject> userData;
RefPtr<InjectedBundleNavigationAction> action = InjectedBundleNavigationAction::create(m_frame, navigationAction, formState);
// Notify the bundle client.
WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNavigationAction(webPage, m_frame, action.get(), request, userData);
if (policy == WKBundlePagePolicyActionUse) {
(m_frame->coreFrame()->loader()->policyChecker()->*function)(PolicyUse);
return;
}
uint64_t listenerID = m_frame->setUpPolicyListener(function);
bool receivedPolicyAction;
uint64_t policyAction;
uint64_t downloadID;
// Notify the UIProcess.
if (!webPage->sendSync(Messages::WebPageProxy::DecidePolicyForNavigationAction(m_frame->frameID(), action->navigationType(), action->modifiers(), action->mouseButton(), request, listenerID, InjectedBundleUserMessageEncoder(userData.get())), Messages::WebPageProxy::DecidePolicyForNavigationAction::Reply(receivedPolicyAction, policyAction, downloadID)))
return;
// We call this synchronously because WebCore cannot gracefully handle a frame load without a synchronous navigation policy reply.
if (receivedPolicyAction)
m_frame->didReceivePolicyDecision(listenerID, static_cast<PolicyAction>(policyAction), downloadID);
}
QNetworkReply* AdBlockNetwork::block(const QNetworkRequest &request)
{
QUrl url = request.url();
if (url.scheme() == "data") {
return 0;
}
AdBlockManager* manager = AdBlockManager::instance();
if (!manager->isEnabled()) {
return 0;
}
QString urlString = url.toEncoded();
const AdBlockRule* blockedRule = 0;
AdBlockSubscription* subscription = manager->subscription();
if (subscription->allow(urlString)) {
return 0;
}
if (const AdBlockRule* rule = subscription->block(urlString)) {
blockedRule = rule;
}
if (blockedRule) {
QVariant v = request.attribute((QNetworkRequest::Attribute)(QNetworkRequest::User + 100));
WebPage* webPage = (WebPage*)(v.value<void*>());
if (webPage) {
webPage->addAdBlockRule(blockedRule->filter(), request.url());
}
AdBlockBlockedNetworkReply* reply = new AdBlockBlockedNetworkReply(request, blockedRule, this);
return reply;
}
return 0;
}
// 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());
}
bool WebProcess::shouldPlugInAutoStartFromOrigin(WebPage& webPage, const String& pageOrigin, const String& pluginOrigin, const String& mimeType)
{
if (!pluginOrigin.isEmpty() && m_plugInAutoStartOrigins.contains(pluginOrigin))
return true;
#ifdef ENABLE_PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC
// The plugin wasn't in the general whitelist, so check if it similar to the primary plugin for the page (if we've found one).
if (webPage.matchesPrimaryPlugIn(pageOrigin, pluginOrigin, mimeType))
return true;
#else
UNUSED_PARAM(webPage);
#endif
// Lastly check against the more explicit hash list.
return isPlugInAutoStartOriginHash(hashForPlugInOrigin(pageOrigin, pluginOrigin, mimeType), webPage.sessionID());
}
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::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 WebFrameLoaderClient::transitionToCommittedForNewPage()
{
WebPage* webPage = m_frame->page();
Color backgroundColor = webPage->drawsTransparentBackground() ? Color::transparent : Color::white;
bool isMainFrame = webPage->mainWebFrame() == m_frame;
bool shouldUseFixedLayout = isMainFrame && webPage->useFixedLayout();
#if !USE(TILED_BACKING_STORE)
const ResourceResponse& response = m_frame->coreFrame()->loader()->documentLoader()->response();
m_frameHasCustomRepresentation = isMainFrame && WebProcess::shared().shouldUseCustomRepresentationForResponse(response);
#endif
m_frame->coreFrame()->createView(webPage->size(), backgroundColor, /* transparent */ false, IntSize(), shouldUseFixedLayout);
m_frame->coreFrame()->view()->setTransparent(!webPage->drawsBackground());
}