void WebProcessProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::MessageDecoder& decoder)
{
if (m_messageReceiverMap.dispatchMessage(connection, messageID, decoder))
return;
if (m_context->dispatchMessage(connection, messageID, decoder))
return;
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveWebProcessProxyMessage(connection, messageID, decoder);
return;
}
#if ENABLE(CUSTOM_PROTOCOLS)
if (messageID.is<CoreIPC::MessageClassCustomProtocolManagerProxy>()) {
m_customProtocolManagerProxy.didReceiveMessage(connection, messageID, decoder);
return;
}
#endif
uint64_t pageID = decoder.destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveMessage(connection, messageID, decoder);
}
void FindPageOverlay::drawRect(GraphicsContext& graphicsContext, const IntRect& dirtyRect)
{
Vector<IntRect> rects = rectsForTextMatches();
ASSERT(!rects.isEmpty());
FrameView* frameView = webPage()->corePage()->mainFrame()->view();
int width = frameView->width();
if (frameView->verticalScrollbar())
width -= frameView->verticalScrollbar()->width();
int height = frameView->height();
if (frameView->horizontalScrollbar())
height -= frameView->horizontalScrollbar()->height();
IntRect paintRect = intersection(dirtyRect, IntRect(0, 0, width, height));
if (paintRect.isEmpty())
return;
graphicsContext.beginTransparencyLayer(1);
graphicsContext.setCompositeOperation(CompositeCopy);
// Draw the background.
graphicsContext.fillRect(paintRect, overlayBackgroundColor(), sRGBColorSpace);
// FIXME: Draw the holes.
graphicsContext.endTransparencyLayer();
}
void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, OwnPtr<CoreIPC::ArgumentEncoder>& reply)
{
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveSyncWebProcessProxyMessage(connection, messageID, arguments, reply);
return;
}
if (messageID.is<CoreIPC::MessageClassWebContext>() || messageID.is<CoreIPC::MessageClassWebContextLegacy>()
#if ENABLE(NETWORK_INFO)
|| messageID.is<CoreIPC::MessageClassWebNetworkInfoManagerProxy>()
#endif
|| messageID.is<CoreIPC::MessageClassDownloadProxy>() || messageID.is<CoreIPC::MessageClassWebIconDatabase>()) {
m_context->didReceiveSyncMessage(this, messageID, arguments, reply);
return;
}
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveSyncMessage(connection, messageID, arguments, reply);
}
SatelliteWindow::SatelliteWindow(MainWindow* pMainWindow, QString name, WebPage* opener) :
GwtWindow(false, true, name, QUrl(), nullptr, opener),
gwtCallback_(pMainWindow, this),
close_(CloseStageOpen)
{
setAttribute(Qt::WA_QuitOnClose, true);
setAttribute(Qt::WA_DeleteOnClose, true);
setWindowIcon(QIcon(QString::fromUtf8(":/icons/RStudio.ico")));
// bind GWT callbacks
auto* channel = webPage()->webChannel();
channel->registerObject(QStringLiteral("desktop"), &gwtCallback_);
// satellites don't have a menu, so connect zoom keyboard shortcuts
// directly
// NOTE: CTRL implies META on macOS
QShortcut* zoomActualSizeShortcut = new QShortcut(Qt::CTRL + Qt::Key_0, this);
#ifdef Q_OS_MAC
QShortcut* zoomInShortcut = new QShortcut(Qt::CTRL + Qt::Key_Equal, this);
#else
QShortcut* zoomInShortcut = new QShortcut(QKeySequence::ZoomIn, this);
#endif
QShortcut* zoomOutShortcut = new QShortcut(QKeySequence::ZoomOut, this);
connect(zoomActualSizeShortcut, SIGNAL(activated()), this, SLOT(zoomActualSize()));
connect(zoomInShortcut, SIGNAL(activated()), this, SLOT(zoomIn()));
connect(zoomOutShortcut, SIGNAL(activated()), this, SLOT(zoomOut()));
}
void DumpRenderTree::dump()
{
// Prevent any further frame load or resource load callbacks from appearing after we dump the result.
DumpRenderTreeSupportQt::dumpFrameLoader(false);
DumpRenderTreeSupportQt::dumpResourceLoadCallbacks(false);
QWebFrame *mainFrame = m_page->mainFrame();
if (isStandAloneMode()) {
QString markup = mainFrame->toHtml();
fprintf(stdout, "Source:\n\n%s\n", markup.toUtf8().constData());
}
QString mimeType = DumpRenderTreeSupportQt::responseMimeType(mainFrame);
if (mimeType == "text/plain")
m_controller->dumpAsText();
// Dump render text...
QString resultString;
if (m_controller->shouldDumpAsText())
resultString = dumpFramesAsText(mainFrame);
else {
resultString = mainFrame->renderTreeDump();
resultString += dumpFrameScrollPosition(mainFrame);
}
if (!resultString.isEmpty()) {
fprintf(stdout, "Content-Type: text/plain\n");
fprintf(stdout, "%s", resultString.toUtf8().constData());
if (m_controller->shouldDumpBackForwardList()) {
fprintf(stdout, "%s", dumpBackForwardList(webPage()).toUtf8().constData());
foreach (QObject* widget, windows) {
QWebPage* page = qobject_cast<QWebPage*>(widget->findChild<QWebPage*>());
fprintf(stdout, "%s", dumpBackForwardList(page).toUtf8().constData());
}
void WebView::contextMenuEvent(QContextMenuEvent *event)
{
QMenu *menu;
// if (page()->contextMenuData().linkUrl().isValid()) {
if (1) {
menu = new QMenu(this);
/*
QAction *m_copy = menu->addAction(tr("&Copy"));
m_copy->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_C));
this->addAction(m_copy, QWebEnginePage::Copy);
QAction *m_paste = menu->addAction(tr("&Paste"));
m_paste->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_V));
this->addAction(m_paste, QWebEnginePage::Paste);
*/
// This doesn't show the shutcut keys - but they work.
menu->addAction(page()->action(QWebEnginePage::Paste));
menu->addAction(page()->action(QWebEnginePage::Copy));
menu->addAction(webPage()->mainWindow()->m_viewMenubar);
menu->addMenu(inputModeMenu);
} else {
menu = page()->createStandardContextMenu();
}
//if (page()->contextMenuData().selectedText().isEmpty())
//menu->addAction(page()->action(QWebEnginePage::SavePage));
connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
menu->popup(event->globalPos());
}
CoreIPC::SyncReplyMode WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
{
#if ENABLE(PLUGIN_PROCESS)
if (messageID.is<CoreIPC::MessageClassWebProcessProxyLegacy>()) {
switch (messageID.get<WebProcessProxyLegacyMessage::Kind>()) {
case WebProcessProxyLegacyMessage::GetPluginProcessConnection: {
String pluginPath;
if (!arguments->decode(CoreIPC::Out(pluginPath)))
return CoreIPC::AutomaticReply;
getPluginProcessConnection(pluginPath, reply);
return CoreIPC::ManualReply;
}
}
}
#endif
if (messageID.is<CoreIPC::MessageClassWebContext>() || messageID.is<CoreIPC::MessageClassWebContextLegacy>() || messageID.is<CoreIPC::MessageClassDownloadProxy>())
return m_context->didReceiveSyncMessage(connection, messageID, arguments, reply);
uint64_t pageID = arguments->destinationID();
if (!pageID)
return CoreIPC::AutomaticReply;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return CoreIPC::AutomaticReply;
pageProxy->didReceiveSyncMessage(connection, messageID, arguments, reply);
return CoreIPC::AutomaticReply;
}
void WebProcessProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
{
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveWebProcessProxyMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebContext>()
|| messageID.is<CoreIPC::MessageClassWebContextLegacy>()
|| messageID.is<CoreIPC::MessageClassDownloadProxy>()
|| messageID.is<CoreIPC::MessageClassWebDatabaseManagerProxy>()) {
m_context->didReceiveMessage(connection, messageID, arguments);
return;
}
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveMessage(connection, messageID, arguments);
}
void SatelliteWindow::closeEvent(QCloseEvent *event)
{
// the source window has special close semantics; if we're not currently closing, then invoke
// custom close handlers.
//
// we only do this for spontaneous (user-initiated) closures; when the window gets shut down by
// its parent or by the OS, we don't prompt since in those cases unsaved document accumulation
// and prompting is handled by the parent.
if (getName().startsWith(QString::fromUtf8(SOURCE_WINDOW_PREFIX)) &&
close_ == CloseStageOpen &&
event->spontaneous())
{
// ignore this event; we need to make sure the window can be
// closed ourselves
event->ignore();
close_ = CloseStagePending;
webPage()->runJavaScript(
QStringLiteral("window.rstudioReadyToClose"),
[&](QVariant qReadyToClose)
{
bool readyToClose = qReadyToClose.toBool();
if (readyToClose)
{
// all clear, close the window
close_ = CloseStageAccepted;
close();
}
else
{
// not ready to close, revert close stage and take care of business
close_ = CloseStageOpen;
webPage()->runJavaScript(
QStringLiteral("window.rstudioCloseSourceWindow()"),
[&](QVariant ignored)
{
// no work to do here
});
}
});
}
else
{
// not a source window, just close it
closeSatellite(event);
}
}
void SatelliteWindow::closeSatellite(QCloseEvent *event)
{
webPage()->runJavaScript(
QStringLiteral(
"if (window.notifyRStudioSatelliteClosing) "
" window.notifyRStudioSatelliteClosing();"));
webView()->event(event);
}
void WebView::applyEncoding()
{
if (m_encoding_in_progress)
return;
if (webPage() && webPage()->mainWindow())
{
QString enc = webPage()->mainWindow()->m_currentEncoding;
if (enc.isEmpty())
return;
if (enc == m_current_encoding && m_current_encoding_url == url() )
return;
QWebPage *page = webPage();
if (!page)
return;
QWebFrame *mainframe = page->mainFrame();
if (!mainframe)
return;
QString html = mainframe->toHtml();
QTextCodec *codec = QTextCodec::codecForName( enc.toAscii() );
if (!codec)
return;
QTextDecoder *decoder = codec->makeDecoder();
if (!decoder)
return;
m_encoding_in_progress = true;
m_current_encoding = enc;
m_current_encoding_url = url();
QString output = decoder->toUnicode(html.toAscii());
mainframe->setHtml(output, mainframe->url());
QList<QWebFrame *> children = mainframe->childFrames();
foreach(QWebFrame *frame, children)
{
html = frame->toHtml();
output = decoder->toUnicode(html.toAscii());
frame->setHtml(output, frame->url());
}
void WebProcess::downloadRequest(uint64_t downloadID, uint64_t initiatingPageID, const ResourceRequest& request)
{
WebPage* initiatingPage = initiatingPageID ? webPage(initiatingPageID) : 0;
ResourceRequest requestWithOriginalURL = request;
if (initiatingPage)
initiatingPage->mainFrame()->loader()->setOriginalURLForDownloadRequest(requestWithOriginalURL);
downloadManager().startDownload(downloadID, requestWithOriginalURL);
}
void SatelliteWindow::closeEvent(QCloseEvent *event)
{
// the source window has special close semantics; if we're not currently
// closing, then invoke custom close handlers
if (getName().startsWith(QString::fromUtf8(SOURCE_WINDOW_PREFIX)) &&
close_ == CloseStageOpen)
{
// ignore this event; we need to make sure the window can be
// closed ourselves
event->ignore();
close_ = CloseStagePending;
webPage()->runJavaScript(
QStringLiteral("window.rstudioReadyToClose"),
[&](QVariant qReadyToClose)
{
bool readyToClose = qReadyToClose.toBool();
if (readyToClose)
{
// all clear, close the window
close_ = CloseStageAccepted;
close();
}
else
{
// not ready to close, revert close stage and take care of business
close_ = CloseStageOpen;
webPage()->runJavaScript(
QStringLiteral("window.rstudioCloseSourceWindow()"),
[&](QVariant ignored)
{
// no work to do here
});
}
});
}
else
{
// not a source window, just close it
closeSatellite(event);
}
}
void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
{
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveSyncMessage(connection, messageID, *arguments, *reply);
}
void WebProcessProxy::didNavigateWithNavigationData(uint64_t pageID, const WebNavigationDataStore& store, uint64_t frameID)
{
WebPageProxy* page = webPage(pageID);
if (!page)
return;
WebFrameProxy* frame = webFrame(frameID);
MESSAGE_CHECK(frame);
MESSAGE_CHECK(frame->page() == page);
m_context->historyClient().didNavigateWithNavigationData(&m_context.get(), page, store, frame);
}
void WebProcessProxy::didUpdateHistoryTitle(uint64_t pageID, const String& title, const String& url, uint64_t frameID)
{
WebPageProxy* page = webPage(pageID);
if (!page)
return;
WebFrameProxy* frame = webFrame(frameID);
MESSAGE_CHECK(frame);
MESSAGE_CHECK(frame->page() == page);
MESSAGE_CHECK_URL(url);
m_context->historyClient().didUpdateHistoryTitle(&m_context.get(), page, title, url, frame);
}
CoreIPC::SyncReplyMode WebProcess::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
{
uint64_t pageID = arguments->destinationID();
if (!pageID)
return CoreIPC::AutomaticReply;
WebPage* page = webPage(pageID);
if (!page)
return CoreIPC::AutomaticReply;
page->didReceiveSyncMessage(connection, messageID, arguments, reply);
return CoreIPC::AutomaticReply;
}
void WebProcessProxy::didPerformServerRedirect(uint64_t pageID, const String& sourceURLString, const String& destinationURLString, uint64_t frameID)
{
WebPageProxy* page = webPage(pageID);
if (!page)
return;
if (sourceURLString.isEmpty() || destinationURLString.isEmpty())
return;
WebFrameProxy* frame = webFrame(frameID);
MESSAGE_CHECK(frame);
MESSAGE_CHECK(frame->page() == page);
MESSAGE_CHECK_URL(sourceURLString);
MESSAGE_CHECK_URL(destinationURLString);
m_context->historyClient().didPerformServerRedirect(&m_context.get(), page, sourceURLString, destinationURLString, frame);
}
PluginView::PluginView(PassRefPtr<HTMLPlugInElement> pluginElement, PassRefPtr<Plugin> plugin, const Plugin::Parameters& parameters)
: PluginViewBase(0)
, m_pluginElement(pluginElement)
, m_plugin(plugin)
, m_webPage(webPage(m_pluginElement.get()))
, m_parameters(parameters)
, m_isInitialized(false)
, m_isWaitingUntilMediaCanStart(false)
, m_isBeingDestroyed(false)
, m_pendingURLRequestsTimer(RunLoop::main(), this, &PluginView::pendingURLRequestsTimerFired)
#if ENABLE(NETSCAPE_PLUGIN_API)
, m_npRuntimeObjectMap(this)
#endif
, m_manualStreamState(StreamStateInitial)
{
m_webPage->addPluginView(this);
}
void WebProcessProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
{
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveWebProcessProxyMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebContext>()
|| messageID.is<CoreIPC::MessageClassWebContextLegacy>()
|| messageID.is<CoreIPC::MessageClassDownloadProxy>()
|| messageID.is<CoreIPC::MessageClassWebApplicationCacheManagerProxy>()
#if ENABLE(BATTERY_STATUS)
|| messageID.is<CoreIPC::MessageClassWebBatteryManagerProxy>()
#endif
|| messageID.is<CoreIPC::MessageClassWebCookieManagerProxy>()
|| messageID.is<CoreIPC::MessageClassWebDatabaseManagerProxy>()
|| messageID.is<CoreIPC::MessageClassWebGeolocationManagerProxy>()
|| messageID.is<CoreIPC::MessageClassWebIconDatabase>()
|| messageID.is<CoreIPC::MessageClassWebKeyValueStorageManagerProxy>()
|| messageID.is<CoreIPC::MessageClassWebMediaCacheManagerProxy>()
#if ENABLE(NETWORK_INFO)
|| messageID.is<CoreIPC::MessageClassWebNetworkInfoManagerProxy>()
#endif
|| messageID.is<CoreIPC::MessageClassWebNotificationManagerProxy>()
#if USE(SOUP)
|| messageID.is<CoreIPC::MessageClassWebSoupRequestManagerProxy>()
#endif
#if ENABLE(VIBRATION)
|| messageID.is<CoreIPC::MessageClassWebVibrationProxy>()
#endif
|| messageID.is<CoreIPC::MessageClassWebResourceCacheManagerProxy>()) {
m_context->didReceiveMessage(this, messageID, arguments);
return;
}
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveMessage(connection, messageID, arguments);
}
void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, OwnPtr<CoreIPC::ArgumentEncoder>& reply)
{
if (m_context->dispatchSyncMessage(connection, messageID, arguments, reply))
return;
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveSyncWebProcessProxyMessage(connection, messageID, arguments, reply);
return;
}
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveSyncMessage(connection, messageID, arguments, reply);
}
void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)
{
if (m_messageReceiverMap.dispatchSyncMessage(connection, messageID, decoder, replyEncoder))
return;
if (m_context->dispatchSyncMessage(connection, messageID, decoder, replyEncoder))
return;
if (messageID.is<CoreIPC::MessageClassWebProcessProxy>()) {
didReceiveSyncWebProcessProxyMessage(connection, messageID, decoder, replyEncoder);
return;
}
uint64_t pageID = decoder.destinationID();
if (!pageID)
return;
WebPageProxy* pageProxy = webPage(pageID);
if (!pageProxy)
return;
pageProxy->didReceiveSyncMessage(connection, messageID, decoder, replyEncoder);
}
Vector<IntRect> FindPageOverlay::rectsForTextMatches()
{
Vector<IntRect> rects;
for (Frame* frame = webPage()->corePage()->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
Document* document = frame->document();
if (!document)
continue;
IntRect visibleRect = frame->view()->visibleContentRect();
Vector<IntRect> frameRects = document->markers()->renderedRectsForMarkers(DocumentMarker::TextMatch);
IntPoint frameOffset(-frame->view()->scrollOffset().width(), -frame->view()->scrollOffset().height());
frameOffset = frame->view()->convertToContainingWindow(frameOffset);
for (Vector<IntRect>::iterator it = frameRects.begin(), end = frameRects.end(); it != end; ++it) {
it->intersect(visibleRect);
it->move(frameOffset.x(), frameOffset.y());
rects.append(*it);
}
}
return rects;
}
DumpRenderTree::DumpRenderTree()
: m_dumpPixels(false)
, m_stdin(0)
, m_enableTextOutput(false)
, m_standAloneMode(false)
, m_graphicsBased(false)
, m_persistentStoragePath(QString(getenv("DUMPRENDERTREE_TEMP")))
{
QByteArray viewMode = getenv("QT_DRT_WEBVIEW_MODE");
if (viewMode == "graphics")
setGraphicsBased(true);
DumpRenderTreeSupportQt::overwritePluginDirectories();
DumpRenderTreeSupportQt::activeMockDeviceOrientationClient(true);
QWebSettings::enablePersistentStorage(m_persistentStoragePath);
m_networkAccessManager = new NetworkAccessManager(this);
// create our primary testing page/view.
if (isGraphicsBased()) {
WebViewGraphicsBased* view = new WebViewGraphicsBased(0);
m_page = new WebPage(view, this);
view->setPage(m_page);
m_mainView = view;
} else {
QWebView* view = new QWebView(0);
m_page = new WebPage(view, this);
view->setPage(m_page);
m_mainView = view;
}
// Use a frame group name for all pages created by DumpRenderTree to allow
// testing of cross-page frame lookup.
DumpRenderTreeSupportQt::webPageSetGroupName(m_page, "org.webkit.qt.DumpRenderTree");
m_mainView->setContextMenuPolicy(Qt::NoContextMenu);
m_mainView->resize(QSize(LayoutTestController::maxViewWidth, LayoutTestController::maxViewHeight));
// clean up cache by resetting quota.
qint64 quota = webPage()->settings()->offlineWebApplicationCacheQuota();
webPage()->settings()->setOfflineWebApplicationCacheQuota(quota);
// create our controllers. This has to be done before connectFrame,
// as it exports there to the JavaScript DOM window.
m_controller = new LayoutTestController(this);
connect(m_controller, SIGNAL(showPage()), this, SLOT(showPage()));
connect(m_controller, SIGNAL(hidePage()), this, SLOT(hidePage()));
// async geolocation permission set by controller
connect(m_controller, SIGNAL(geolocationPermissionSet()), this, SLOT(geolocationPermissionSet()));
connect(m_controller, SIGNAL(done()), this, SLOT(dump()));
m_eventSender = new EventSender(m_page);
m_textInputController = new TextInputController(m_page);
m_plainTextController = new PlainTextController(m_page);
m_gcController = new GCController(m_page);
// now connect our different signals
connect(m_page, SIGNAL(frameCreated(QWebFrame *)),
this, SLOT(connectFrame(QWebFrame *)));
connectFrame(m_page->mainFrame());
connect(m_page, SIGNAL(loadFinished(bool)),
m_controller, SLOT(maybeDump(bool)));
// We need to connect to loadStarted() because notifyDone should only
// dump results itself when the last page loaded in the test has finished loading.
connect(m_page, SIGNAL(loadStarted()),
m_controller, SLOT(resetLoadFinished()));
connect(m_page, SIGNAL(windowCloseRequested()), this, SLOT(windowCloseRequested()));
connect(m_page, SIGNAL(printRequested(QWebFrame*)), this, SLOT(dryRunPrint(QWebFrame*)));
connect(m_page->mainFrame(), SIGNAL(titleChanged(const QString&)),
SLOT(titleChanged(const QString&)));
connect(m_page, SIGNAL(databaseQuotaExceeded(QWebFrame*,QString)),
this, SLOT(dumpDatabaseQuota(QWebFrame*,QString)));
connect(m_page, SIGNAL(applicationCacheQuotaExceeded(QWebSecurityOrigin *, quint64)),
this, SLOT(dumpApplicationCacheQuota(QWebSecurityOrigin *, quint64)));
connect(m_page, SIGNAL(statusBarMessage(const QString&)),
this, SLOT(statusBarMessage(const QString&)));
QObject::connect(this, SIGNAL(quit()), qApp, SLOT(quit()), Qt::QueuedConnection);
DumpRenderTreeSupportQt::setDumpRenderTreeModeEnabled(true);
QFocusEvent event(QEvent::FocusIn, Qt::ActiveWindowFocusReason);
QApplication::sendEvent(m_mainView, &event);
}
void WebProcess::downloadRequest(uint64_t downloadID, uint64_t initiatingPageID, const ResourceRequest& request)
{
WebPage* initiatingPage = initiatingPageID ? webPage(initiatingPageID) : 0;
DownloadManager::shared().startDownload(downloadID, initiatingPage, request);
}
void WebProcess::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
{
if (messageID.is<CoreIPC::MessageClassWebProcess>()) {
didReceiveWebProcessMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassAuthenticationManager>()) {
AuthenticationManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebApplicationCacheManager>()) {
WebApplicationCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebCookieManager>()) {
WebCookieManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebDatabaseManager>()) {
WebDatabaseManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebGeolocationManager>()) {
m_geolocationManager.didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebIconDatabaseProxy>()) {
m_iconDatabaseProxy.didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebKeyValueStorageManager>()) {
WebKeyValueStorageManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebMediaCacheManager>()) {
WebMediaCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassWebResourceCacheManager>()) {
WebResourceCacheManager::shared().didReceiveMessage(connection, messageID, arguments);
return;
}
if (messageID.is<CoreIPC::MessageClassInjectedBundle>()) {
if (!m_injectedBundle)
return;
m_injectedBundle->didReceiveMessage(connection, messageID, arguments);
return;
}
uint64_t pageID = arguments->destinationID();
if (!pageID)
return;
WebPage* page = webPage(pageID);
if (!page)
return;
page->didReceiveMessage(connection, messageID, arguments);
}
