Added partial ICacheManager implementation

There's no support for persistant configuration, but there is support for
actually controlling the cache behaviour of the browser. The fetching behaviour
is controlled by passing a cache behavioural parameter to the load()-function
of the QGraphicsWebView.

12 files changed, 203 insertions, 30 deletions

diff --git a/browser/browser.cpp b/browser/browser.cpp
index cce4982..0bcbc00 100644
--- a/browser/browser.cpp
+++ b/browser/browser.cpp
@@ -18,10 +18,14 @@
 #include "browser.h"
 #include "browserview.h"
 
-browser::browser(QObject *parent) :
+browser::browser(cachemanager *manager, QObject *parent) :
     QObject(parent)
 {
     qDebug() << __PRETTY_FUNCTION__;
+    if (manager) {
+        qDebug() << "Setting default cacheManager";
+        m_cacheManager = manager;
+    }
 }
 
 conn::brw::ERROR_IDS browser::createPageWindow(int a_eDeviceId, const conn::brw::Rect & a_oGeometry, conn::brw::OBJECT_HANDLE &a_hPageWindowHandle) {
@@ -30,6 +34,9 @@ conn::brw::ERROR_IDS browser::createPageWindow(int a_eDeviceId, const conn::brw:
     Q_UNUSED(a_eDeviceId);
 
     BrowserView *bvi = new BrowserView();
+    if (m_cacheManager)
+        bvi->setCacheManager (m_cacheManager);
+
     bvi->setGeometry(a_oGeometry.i32X, a_oGeometry.i32Y, a_oGeometry.i32Width,
                          a_oGeometry.i32Height);
     bvi->show();
diff --git a/browser/browser.h b/browser/browser.h
index 06b982d..871ad32 100644
--- a/browser/browser.h
+++ b/browser/browser.h
@@ -27,8 +27,8 @@ class browser : public QObject, protected QDBusContext
 {
     Q_OBJECT
 public:
-    explicit browser(QObject *parent = 0);
-    
+    explicit browser(cachemanager *defaultManager = 0, QObject *parent = 0);
+
     webpagewindow *wpw;
     userinput *ui;
 
@@ -36,6 +36,9 @@ signals:
     void onPageWindowCreated(qlonglong a_hPageWindowHandle, conn::brw::ERROR_IDS a_eErrorId);
     void onPageWindowDestroyed(qlonglong a_hPageWindowHandle);
 
+    // Distribute cache changes signals to all browser windows
+
+
 public Q_SLOTS:
     conn::brw::ERROR_IDS createPageWindow(int a_eDeviceId, const conn::brw::Rect & a_oGeometry,
                                           conn::brw::OBJECT_HANDLE &a_hPageWindowHandle);
@@ -45,10 +48,11 @@ public Q_SLOTS:
     void inputText(QString input);
     void setView(QString viewpath);
 
-    
+
 private:
     QHash<conn::brw::OBJECT_HANDLE, QWidget*> windowhash;
     QHash<QString, BrowserView *> webviewhash;
+    cachemanager *m_cacheManager = NULL;
 };
 
 #endif // BROWSER_H
diff --git a/browser/browserconfig.cpp b/browser/browserconfig.cpp
index 46446f5..ecca016 100644
--- a/browser/browserconfig.cpp
+++ b/browser/browserconfig.cpp
@@ -17,10 +17,12 @@
 template void      BrowserConfig::setValue<int>(BrowserConfig::BrowserConfigKey, int);
 template void      BrowserConfig::setValue<QString>(BrowserConfig::BrowserConfigKey, QString);
 template void      BrowserConfig::setValue<qlonglong>(BrowserConfig::BrowserConfigKey, qlonglong);
+template void      BrowserConfig::setValue<qulonglong>(BrowserConfig::BrowserConfigKey, qulonglong);
 
 template int       BrowserConfig::getValue<int>(BrowserConfig::BrowserConfigKey);
 template QString   BrowserConfig::getValue<QString>(BrowserConfig::BrowserConfigKey);
 template qlonglong BrowserConfig::getValue<qlonglong>(BrowserConfig::BrowserConfigKey);
+template qulonglong BrowserConfig::getValue<qulonglong>(BrowserConfig::BrowserConfigKey);
 
 BrowserConfig::BrowserConfig() {
     m_qsettings = new QSettings("browserpoc");
diff --git a/browser/browserhelper.cpp b/browser/browserhelper.cpp
index f83aa30..0760b69 100644
--- a/browser/browserhelper.cpp
+++ b/browser/browserhelper.cpp
@@ -40,7 +40,14 @@ browserhelper::browserhelper(QString instanceId, QObject *parent) :
         exit(1);
     }
 
-    browser *br = new browser();
+    cachemanager *cm = new cachemanager();
+    new ICacheManagerAdaptor(cm);
+    if(!connection->registerObject("/Browser/ICacheManager", cm)) {
+        qDebug() << "failed register object ICacheManager";
+        exit(1);
+    }
+
+    browser *br = new browser(cm);
     new IBrowserAdaptor(br);
     if(!connection->registerObject("/Browser/IBrowser", br)) {
         qDebug() << "failed register object IBrowser";
@@ -54,13 +61,6 @@ browserhelper::browserhelper(QString instanceId, QObject *parent) :
         exit(1);
     }
 
-    cachemanager *cm = new cachemanager();
-    new ICacheManagerAdaptor(cm);
-    if(!connection->registerObject("/Browser/ICacheManager", cm)) {
-        qDebug() << "failed register object ICacheManager";
-        exit(1);
-    }
-
     wpw = new webpagewindow();
     new IWebPageWindowAdaptor(wpw);
     br->wpw = wpw;
@@ -91,5 +91,6 @@ void browserhelper::registertypes() {
     qDBusRegisterMetaType<conn::brw::BrowserActions>();
     qDBusRegisterMetaType<conn::brw::OBJECT_HANDLE>();
     qDBusRegisterMetaType<conn::brw::ObjectHandleList>();
+    qDBusRegisterMetaType<conn::brw::CACHE_POLICY>();
 }
 
diff --git a/browser/browserview.cpp b/browser/browserview.cpp
index 38be237..ad44402 100644
--- a/browser/browserview.cpp
+++ b/browser/browserview.cpp
@@ -58,7 +58,15 @@ BrowserView::BrowserView()
 
 bool BrowserView::load(const QString &a_Url)
 {
-    m_webview.load(a_Url);
+    if (m_cacheManager) {
+        QNetworkRequest req = QNetworkRequest(QUrl(a_Url));
+        req.setAttribute(QNetworkRequest::CacheLoadControlAttribute,
+                         m_cacheManager->getCacheLoadControl());
+        m_webview.load(req);
+    } else {
+        qDebug() << "No cacheManager present, defaulting to load(url)";
+        m_webview.load(a_Url);
+    }
     return true;
 }
 
@@ -258,3 +266,12 @@ void BrowserView::select() {
 void BrowserView::activate() {
     this->activateWindow();
 }
+
+void BrowserView::setCacheManager(cachemanager *cm) {
+    if (cm) {
+        qDebug() << "Setting cacheManager" << cm;
+        m_cacheManager = cm;
+        m_webview.page()->setNetworkAccessManager(cm->getNetworkAccessManager());
+    } else
+        qDebug() << "Setting NULL networkManager!";
+}
diff --git a/browser/browserview.h b/browser/browserview.h
index 36469e5..853c66f 100644
--- a/browser/browserview.h
+++ b/browser/browserview.h
@@ -20,7 +20,9 @@
 #include <QWebElement>
 #include <QDebug>
 #include <QSemaphore>
+#include <QNetworkAccessManager>
 
+#include "cachemanager.h"
 #include "../common/browserdefs.h"
 
 class WebPageWaiter : public QObject {
@@ -80,6 +82,7 @@ public:
     QString getFaviconFilePath(QString url);
     void activate();
     void select();
+    void setCacheManager (cachemanager *nm);
 
 signals:
     void pageLoadStarted();
@@ -119,6 +122,7 @@ private:
     int m_currentProgress;
     uint m_scrollPositionX;
     uint m_scrollPositionY;
+    cachemanager *m_cacheManager = NULL;
 };
 
 
diff --git a/browser/cachemanager.cpp b/browser/cachemanager.cpp
index 5d29d62..161d5e0 100644
--- a/browser/cachemanager.cpp
+++ b/browser/cachemanager.cpp
@@ -14,32 +14,80 @@
 #include <QObject>
 #include <QDBusContext>
 #include <QDebug>
+#include <QAbstractNetworkCache>
+#include <QNetworkDiskCache>
 
 #include "cachemanager.h"
 #include "../common/browserdefs.h"
 
-cachemanager::cachemanager(QObject *parent) : 
+cachemanager::cachemanager(QObject *parent) :
     QObject(parent)
 {
     m_config = new BrowserConfig();
+    m_manager = new QNetworkAccessManager();
+    QNetworkDiskCache *cache = new QNetworkDiskCache();
+    cache->setCacheDirectory ("cache");
+    if (cache)
+        m_manager->setCache(cache);
+    else
+        qDebug() << "Unable to create cache file!";
 }
 
 qlonglong cachemanager::getCacheSize(){
-    return m_config->getValue<qlonglong>(BrowserConfig::CONFIG_CACHESIZE);
+    if (!m_manager->cache()) {
+        qDebug() << "Unable to retreive cache!";
+        return 0;
+    }
+    return m_manager->cache()->cacheSize();
 }
 
 conn::brw::CACHE_POLICY cachemanager::getCachePolicy(){
     qDebug() << "Getting cache policy";
-    return conn::brw::CP_CACHE_ONLY;
+    return m_policy;
 }
-qlonglong cachemanager::getMaximumCacheSize(){}
+
+qlonglong cachemanager::getMaximumCacheSize(){
+    if (!m_manager->cache()) {
+        qDebug() << "Unable to retreive cache!";
+        return 0;
+    }
+    QNetworkDiskCache *cache = qobject_cast<QNetworkDiskCache *>(m_manager->cache());
+    if (cache)
+        return cache->maximumCacheSize();
+    else {
+        qDebug() << "Unable to retrieve max cache size";
+        return 0;
+    }
+}
+
 conn::brw::ERROR_IDS cachemanager::setCachePolicy(conn::brw::CACHE_POLICY pol)
 {
-    emit onCachePolicyChanged(pol);
-    qDebug() << "TODO: setCachePolicy";
+    m_policy = pol;
+    return conn::brw::EID_NO_ERROR;
 }
+
 conn::brw::ERROR_IDS cachemanager::clearCache()
 {
-    emit onClearCache();
-    qDebug() << "TODO: clearCache";
+    m_manager->cache()->clear();
+    return conn::brw::EID_NO_ERROR;
+}
+
+QNetworkAccessManager *cachemanager::getNetworkAccessManager()
+{
+    return m_manager;
+}
+
+QNetworkRequest::CacheLoadControl cachemanager::getCacheLoadControl()
+{
+    switch (m_policy) {
+        case conn::brw::CP_ONLINE_CACHE:
+            return QNetworkRequest::PreferCache;
+        case conn::brw::CP_CACHE_ONLY:
+            return QNetworkRequest::AlwaysCache;
+        case conn::brw::CP_ONLINE_ONLY:
+            return QNetworkRequest::AlwaysNetwork;
+        default:
+            qDebug() << "Illegal cache policy!";
+            return QNetworkRequest::PreferCache;
+    }
 }
diff --git a/browser/cachemanager.h b/browser/cachemanager.h
index 4e46224..4a821db 100644
--- a/browser/cachemanager.h
+++ b/browser/cachemanager.h
@@ -16,6 +16,8 @@
 
 #include <QObject>
 #include <QDBusContext>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
 
 #include "browserconfig.h"
 #include "../common/browserdefs.h"
@@ -25,13 +27,11 @@ class cachemanager : public QObject, protected QDBusContext
     Q_OBJECT
 public:
     cachemanager(QObject *parent = 0);
+    QNetworkAccessManager *getNetworkAccessManager();
+    QNetworkRequest::CacheLoadControl getCacheLoadControl();
 
 signals:
-    void onCacheChanged();
-
-    // Intenal signals
-    void onCachePolicyChanged(conn::brw::CACHE_POLICY);
-    void onClearCache();
+    void cacheChanged();
 
 public Q_SLOTS:
     qlonglong getCacheSize();
@@ -42,6 +42,8 @@ public Q_SLOTS:
 
 private:
     BrowserConfig *m_config = NULL;
+    conn::brw::CACHE_POLICY m_policy;
+    QNetworkAccessManager *m_manager = NULL;
 };
 
 #endif // CACHEMANAGER_H
diff --git a/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.cpp b/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.cpp
index 194d380..6bf51b8 100644
--- a/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.cpp
+++ b/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.cpp
@@ -30,8 +30,26 @@ void TestCacheManagerDBus::cleanupTestCase() {
 
 ///////////////// Test cases  ///////////////
 
-void TestCacheManagerDBus::testGetCacheSize() {
+void TestCacheManagerDBus::testSetGetCacheSize() {
     m_cdb->getCacheSize();
 }
 
+void TestCacheManagerDBus::testSetGetCachePolicy() {
+    m_cdb->setCachePolicy(conn::brw::CP_CACHE_ONLY);
+    QVERIFY(m_cdb->getCachePolicy() == conn::brw::CP_CACHE_ONLY);
+
+    m_cdb->setCachePolicy(conn::brw::CP_ONLINE_ONLY);
+    QVERIFY(m_cdb->getCachePolicy() == conn::brw::CP_ONLINE_ONLY);
+}
+
+void TestCacheManagerDBus::testGetMaximumCacheSize() {
+    m_cdb->getMaximumCacheSize();
+}
+
+void TestCacheManagerDBus::testCanClearCache() {
+    qulonglong old = m_cdb->getCacheSize();
+    m_cdb->clearCache();
+    QVERIFY (m_cdb->getCacheSize() <= old);
+}
+
 QTEST_MAIN (TestCacheManagerDBus);
diff --git a/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.h b/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.h
index bc36121..3b306c8 100644
--- a/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.h
+++ b/browser/unit-tests/cachemanagerdbus/testcachemanagerdbus.h
@@ -23,7 +23,10 @@ private slots:
     void initTestCase();
     void cleanupTestCase();
 
-    void testGetCacheSize();
+    void testSetGetCacheSize();
+    void testSetGetCachePolicy();
+    void testGetMaximumCacheSize();
+    void testCanClearCache();
 
 private:
    CacheManagerDbus *m_cdb  = NULL;
diff --git a/common/cachemanagerdbus.cpp b/common/cachemanagerdbus.cpp
index 9f43174..6431634 100644
--- a/common/cachemanagerdbus.cpp
+++ b/common/cachemanagerdbus.cpp
@@ -28,6 +28,7 @@ CacheManagerDbus::CacheManagerDbus(QObject *parent) :
 
 void CacheManagerDbus::registertypes() {
     qDBusRegisterMetaType<conn::brw::CACHE_POLICY>();
+    qDBusRegisterMetaType<conn::brw::ERROR_IDS>();
 }
 
 void CacheManagerDbus::connectdbussession(QString id) {
@@ -48,7 +49,7 @@ void CacheManagerDbus::connectdbussession(QString id) {
 }
 
 
-qlonglong CacheManagerDbus::getCacheSize() {
+qulonglong CacheManagerDbus::getCacheSize() {
     qDebug() << __PRETTY_FUNCTION__;
 
     qulonglong ret;
@@ -63,3 +64,65 @@ qlonglong CacheManagerDbus::getCacheSize() {
     }
     return ret;
 }
+
+conn::brw::CACHE_POLICY CacheManagerDbus::getCachePolicy() {
+    qDebug() << __PRETTY_FUNCTION__;
+
+    conn::brw::CACHE_POLICY ret;
+    QDBusReply<conn::brw::CACHE_POLICY> reply = m_cachemanager->getCachePolicy();
+
+    if(reply.isValid()) {
+        ret = reply.value();
+        qDebug() << "ERROR_IDS " << ret;
+    } else {
+        QDBusError error = reply.error();
+        qDebug() << "ERROR " << error.name() << error.message();
+    }
+    return ret;
+}
+
+void CacheManagerDbus::setCachePolicy(conn::brw::CACHE_POLICY policy) {
+    qDebug() << __PRETTY_FUNCTION__;
+
+    QDBusReply<conn::brw::ERROR_IDS> reply = m_cachemanager->setCachePolicy(policy);
+
+    if(reply.isValid()) {
+        conn::brw::ERROR_IDS ret;
+        ret = reply.value();
+        qDebug() << "ERROR_IDS " << ret;
+    } else {
+        QDBusError error = reply.error();
+        qDebug() << "ERROR " << error.name() << error.message();
+    }
+}
+
+qulonglong CacheManagerDbus::getMaximumCacheSize() {
+    qDebug() << __PRETTY_FUNCTION__;
+
+    qlonglong ret;
+    QDBusReply<qulonglong> reply = m_cachemanager->getMaximumCacheSize();
+
+    if(reply.isValid()) {
+        ret = reply.value();
+        qDebug() << "ERROR_IDS " << ret;
+    } else {
+        QDBusError error = reply.error();
+        qDebug() << "ERROR " << error.name() << error.message();
+    }
+    return ret;
+}
+
+void CacheManagerDbus::clearCache() {
+    qDebug() << __PRETTY_FUNCTION__;
+
+    QDBusReply<conn::brw::ERROR_IDS> reply = m_cachemanager->clearCache();
+
+    if(reply.isValid()) {
+        conn::brw::ERROR_IDS ret;
+        ret = reply.value();
+        qDebug() << "ERROR_IDS " << ret;
+    } else {
+        QDBusError error = reply.error();
+        qDebug() << "ERROR " << error.name() << error.message();
+    }
+}
diff --git a/common/cachemanagerdbus.h b/common/cachemanagerdbus.h
index 42eb321..ff94f55 100644
--- a/common/cachemanagerdbus.h
+++ b/common/cachemanagerdbus.h
@@ -28,7 +28,11 @@ public:
     explicit CacheManagerDbus(QObject *parent = 0);
 
     void connectdbussession(QString id);
-    Q_INVOKABLE qlonglong getCacheSize();
+    Q_INVOKABLE qulonglong getCacheSize();
+    Q_INVOKABLE conn::brw::CACHE_POLICY getCachePolicy();
+    Q_INVOKABLE void setCachePolicy(conn::brw::CACHE_POLICY);
+    Q_INVOKABLE qulonglong getMaximumCacheSize();
+    Q_INVOKABLE void clearCache();
 
 signals:
     void onCacheChanged();