233 lines
6.1 KiB
C++
233 lines
6.1 KiB
C++
#include "WebPageManager.h"
|
|
#include "WebPage.h"
|
|
#include "NetworkCookieJar.h"
|
|
#include "NetworkAccessManager.h"
|
|
#include "BlacklistedRequestHandler.h"
|
|
#include "CustomHeadersRequestHandler.h"
|
|
#include "MissingContentHeaderRequestHandler.h"
|
|
#include "UnknownUrlHandler.h"
|
|
#include "NetworkRequestFactory.h"
|
|
#include <QWebSettings>
|
|
|
|
WebPageManager::WebPageManager(QObject *parent) : QObject(parent) {
|
|
m_ignoreSslErrors = false;
|
|
m_cookieJar = new NetworkCookieJar(this);
|
|
m_success = true;
|
|
m_loggingEnabled = false;
|
|
m_isCacheInitialized = false;
|
|
m_ignoredOutput = new QFile(this);
|
|
m_timeout = -1;
|
|
m_customHeadersRequestHandler = new CustomHeadersRequestHandler(
|
|
new MissingContentHeaderRequestHandler(
|
|
new NetworkRequestFactory(this),
|
|
this
|
|
),
|
|
this
|
|
);
|
|
m_unknownUrlHandler =
|
|
new UnknownUrlHandler(m_customHeadersRequestHandler, this);
|
|
m_blacklistedRequestHandler =
|
|
new BlacklistedRequestHandler(m_unknownUrlHandler, this);
|
|
m_networkAccessManager =
|
|
new NetworkAccessManager(m_blacklistedRequestHandler, this);
|
|
m_networkAccessManager->setCookieJar(m_cookieJar);
|
|
|
|
createPage()->setFocus();
|
|
}
|
|
|
|
NetworkAccessManager *WebPageManager::networkAccessManager() {
|
|
return m_networkAccessManager;
|
|
}
|
|
|
|
void WebPageManager::append(WebPage *value) {
|
|
m_pages.append(value);
|
|
}
|
|
|
|
QList<WebPage *> WebPageManager::pages() const {
|
|
return m_pages;
|
|
}
|
|
|
|
void WebPageManager::setCurrentPage(WebPage *page) {
|
|
m_currentPage = page;
|
|
}
|
|
|
|
WebPage *WebPageManager::currentPage() const {
|
|
return m_currentPage;
|
|
}
|
|
|
|
WebPage *WebPageManager::createPage() {
|
|
WebPage *page = new WebPage(this);
|
|
initOfflineWebApplicationCache();
|
|
page->createWindow();
|
|
|
|
connect(page, SIGNAL(loadStarted()),
|
|
this, SLOT(emitLoadStarted()));
|
|
connect(page, SIGNAL(pageFinished(bool)),
|
|
this, SLOT(setPageStatus(bool)));
|
|
connect(page, SIGNAL(requestCreated(QByteArray &, QNetworkReply *)),
|
|
this, SLOT(requestCreated(QByteArray &, QNetworkReply *)));
|
|
append(page);
|
|
return page;
|
|
}
|
|
|
|
void WebPageManager::removePage(WebPage *page) {
|
|
m_pages.removeOne(page);
|
|
page->deleteLater();
|
|
if (m_pages.isEmpty())
|
|
createPage()->setFocus();
|
|
else if (page == m_currentPage)
|
|
m_pages.first()->setFocus();
|
|
}
|
|
|
|
void WebPageManager::emitLoadStarted() {
|
|
if (m_started.empty()) {
|
|
log() << "Load started";
|
|
emit loadStarted();
|
|
}
|
|
m_started += qobject_cast<WebPage *>(sender());
|
|
}
|
|
|
|
void WebPageManager::requestCreated(QByteArray &url, QNetworkReply *reply) {
|
|
log() << "Started request to" << url;
|
|
if (reply->isFinished())
|
|
replyFinished(reply);
|
|
else {
|
|
m_pendingReplies.append(reply);
|
|
connect(reply, SIGNAL(finished()), SLOT(handleReplyFinished()));
|
|
connect(
|
|
reply,
|
|
SIGNAL(destroyed(QObject *)),
|
|
SLOT(replyDestroyed(QObject *))
|
|
);
|
|
}
|
|
}
|
|
|
|
void WebPageManager::handleReplyFinished() {
|
|
QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
|
|
disconnect(reply, SIGNAL(finished()), this, SLOT(handleReplyFinished()));
|
|
replyFinished(reply);
|
|
}
|
|
|
|
void WebPageManager::replyFinished(QNetworkReply *reply) {
|
|
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
|
|
log() << "Received" << status << "from" << reply->url().toString();
|
|
m_pendingReplies.removeAll(reply);
|
|
}
|
|
|
|
void WebPageManager::replyDestroyed(QObject *reply) {
|
|
m_pendingReplies.removeAll((QNetworkReply *) reply);
|
|
}
|
|
|
|
void WebPageManager::setPageStatus(bool success) {
|
|
log() << "Page finished with" << success;
|
|
m_started.remove(qobject_cast<WebPage *>(sender()));
|
|
m_success = success && m_success;
|
|
if (m_started.empty()) {
|
|
emitPageFinished();
|
|
}
|
|
}
|
|
|
|
void WebPageManager::emitPageFinished() {
|
|
log() << "Load finished";
|
|
emit pageFinished(m_success);
|
|
m_success = true;
|
|
}
|
|
|
|
void WebPageManager::setIgnoreSslErrors(bool value) {
|
|
m_ignoreSslErrors = value;
|
|
}
|
|
|
|
bool WebPageManager::ignoreSslErrors() {
|
|
return m_ignoreSslErrors;
|
|
}
|
|
|
|
int WebPageManager::getTimeout() {
|
|
return m_timeout;
|
|
}
|
|
|
|
void WebPageManager::setTimeout(int timeout) {
|
|
m_timeout = timeout;
|
|
}
|
|
|
|
void WebPageManager::reset() {
|
|
foreach(QNetworkReply *reply, m_pendingReplies) {
|
|
log() << "Aborting request to" << reply->url().toString();
|
|
reply->abort();
|
|
}
|
|
m_pendingReplies.clear();
|
|
|
|
while (!m_pages.isEmpty()) {
|
|
WebPage *page = m_pages.takeFirst();
|
|
page->deleteLater();
|
|
}
|
|
|
|
m_timeout = -1;
|
|
m_cookieJar->clearCookies();
|
|
m_networkAccessManager->reset();
|
|
m_customHeadersRequestHandler->reset();
|
|
m_currentPage->resetLocalStorage();
|
|
m_blacklistedRequestHandler->reset();
|
|
m_unknownUrlHandler->reset();
|
|
|
|
|
|
qint64 size = QWebSettings::offlineWebApplicationCacheQuota();
|
|
// No public function was found to wrap the empty() call to
|
|
// WebCore::cacheStorage().empty()
|
|
QWebSettings::setOfflineWebApplicationCacheQuota(size);
|
|
|
|
createPage()->setFocus();
|
|
}
|
|
|
|
NetworkCookieJar *WebPageManager::cookieJar() {
|
|
return m_cookieJar;
|
|
}
|
|
|
|
bool WebPageManager::isLoading() const {
|
|
foreach(WebPage *page, pages()) {
|
|
if (page->isLoading()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
QDebug WebPageManager::log() const {
|
|
if (m_loggingEnabled) {
|
|
return qCritical() << qPrintable(QTime::currentTime().toString("hh:mm:ss.zzz"));
|
|
} else {
|
|
return QDebug(m_ignoredOutput);
|
|
}
|
|
}
|
|
|
|
void WebPageManager::enableLogging() {
|
|
m_loggingEnabled = true;
|
|
}
|
|
|
|
void WebPageManager::setUrlBlacklist(const QStringList &urls) {
|
|
m_blacklistedRequestHandler->setUrlBlacklist(urls);
|
|
}
|
|
|
|
void WebPageManager::addHeader(QString key, QString value) {
|
|
m_customHeadersRequestHandler->addHeader(key, value);
|
|
}
|
|
|
|
void WebPageManager::setUnknownUrlMode(UnknownUrlHandler::Mode mode) {
|
|
m_unknownUrlHandler->setMode(mode);
|
|
}
|
|
|
|
void WebPageManager::allowUrl(const QString &url) {
|
|
m_unknownUrlHandler->allowUrl(url);
|
|
}
|
|
|
|
void WebPageManager::blockUrl(const QString &url) {
|
|
m_blacklistedRequestHandler->blockUrl(url);
|
|
}
|
|
|
|
void WebPageManager::initOfflineWebApplicationCache() {
|
|
if (!m_isCacheInitialized && QFileInfo("tmp").isDir()) {
|
|
QWebSettings::globalSettings()->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, true);
|
|
QWebSettings::globalSettings()->setOfflineWebApplicationCachePath("tmp");
|
|
m_isCacheInitialized = true;
|
|
}
|
|
}
|