diff --git a/autotests/gravatarresolvurljobtest.cpp b/autotests/gravatarresolvurljobtest.cpp
index 66bbd8d..89edf41 100644
--- a/autotests/gravatarresolvurljobtest.cpp
+++ b/autotests/gravatarresolvurljobtest.cpp
@@ -1,182 +1,174 @@
 /*
    Copyright (c) 2015-2017 Laurent Montel <montel@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "gravatarresolvurljobtest.h"
 #include "../src/job/gravatarresolvurljob.h"
 #include <qtest.h>
 
 GravatarResolvUrlJobTest::GravatarResolvUrlJobTest(QObject *parent)
     : QObject(parent)
 {
 }
 
 GravatarResolvUrlJobTest::~GravatarResolvUrlJobTest()
 {
 }
 
 void GravatarResolvUrlJobTest::shouldHaveDefaultValue()
 {
     Gravatar::GravatarResolvUrlJob job;
     QVERIFY(job.email().isEmpty());
     QCOMPARE(job.size(), 80);
     QCOMPARE(job.hasGravatar(), false);
     QCOMPARE(job.pixmap().isNull(), true);
     QCOMPARE(job.useDefaultPixmap(), false);
-    QCOMPARE(job.useCache(), false);
     QCOMPARE(job.useLibravatar(), false);
     QCOMPARE(job.fallbackGravatar(), true);
 }
 
 void GravatarResolvUrlJobTest::shouldChangeValue()
 {
     Gravatar::GravatarResolvUrlJob job;
-    bool useCache = true;
-    job.setUseCache(useCache);
-    QCOMPARE(job.useCache(), useCache);
-    useCache = false;
-    job.setUseCache(useCache);
-    QCOMPARE(job.useCache(), useCache);
-
     bool useDefaultPixmap = true;
     job.setUseDefaultPixmap(useDefaultPixmap);
     QCOMPARE(job.useDefaultPixmap(), useDefaultPixmap);
 
     useDefaultPixmap = false;
     job.setUseDefaultPixmap(useDefaultPixmap);
     QCOMPARE(job.useDefaultPixmap(), useDefaultPixmap);
 
     bool useLibravatar = true;
     job.setUseLibravatar(useLibravatar);
     QCOMPARE(job.useLibravatar(), useLibravatar);
 
     useLibravatar = false;
     job.setUseLibravatar(useLibravatar);
     QCOMPARE(job.useLibravatar(), useLibravatar);
 
     bool fallBackGravatar = false;
     job.setFallbackGravatar(fallBackGravatar);
     QCOMPARE(job.fallbackGravatar(), fallBackGravatar);
     fallBackGravatar = true;
     job.setFallbackGravatar(fallBackGravatar);
     QCOMPARE(job.fallbackGravatar(), fallBackGravatar);
 }
 
 void GravatarResolvUrlJobTest::shouldChangeSize()
 {
     Gravatar::GravatarResolvUrlJob job;
     int size = 50;
     job.setSize(size);
     QCOMPARE(job.size(), size);
     size = 0;
     job.setSize(size);
     QCOMPARE(job.size(), 80);
 
     size = 10;
     job.setSize(size);
     QCOMPARE(job.size(), size);
 
     size = 2048;
     job.setSize(size);
     QCOMPARE(job.size(), size);
 
     size = 4096;
     job.setSize(size);
     QCOMPARE(job.size(), 2048);
 }
 
 void GravatarResolvUrlJobTest::shouldAddSizeInUrl()
 {
     Gravatar::GravatarResolvUrlJob job;
     job.setEmail(QStringLiteral("foo@kde.org"));
     job.setSize(1024);
     job.setUseLibravatar(false);
     QUrl url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(url, QUrl(QStringLiteral("https://secure.gravatar.com:443/avatar/89b4e14cf2fc6d426275c019c6dc9de6?d=404&s=1024")));
     job.setUseLibravatar(true);
     url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(url, QUrl(QStringLiteral("https://seccdn.libravatar.org:443/avatar/2726400c3a33ce56c0ff632cbc0474f766d3b36e68819c601fb02954c1681d85?d=404&s=1024")));
 }
 
 void GravatarResolvUrlJobTest::shouldUseDefaultPixmap()
 {
     Gravatar::GravatarResolvUrlJob job;
     job.setEmail(QStringLiteral("foo@kde.org"));
     job.setSize(1024);
     job.setUseDefaultPixmap(true);
     QUrl url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(url, QUrl(QStringLiteral("https://secure.gravatar.com:443/avatar/89b4e14cf2fc6d426275c019c6dc9de6?s=1024")));
 }
 
 void GravatarResolvUrlJobTest::shouldUseHttps()
 {
     Gravatar::GravatarResolvUrlJob job;
     job.setEmail(QStringLiteral("foo@kde.org"));
     job.setSize(1024);
     job.setUseLibravatar(false);
     QUrl url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(url, QUrl(QStringLiteral("https://secure.gravatar.com:443/avatar/89b4e14cf2fc6d426275c019c6dc9de6?d=404&s=1024")));
     job.setUseLibravatar(true);
     url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(url, QUrl(QStringLiteral("https://seccdn.libravatar.org:443/avatar/2726400c3a33ce56c0ff632cbc0474f766d3b36e68819c601fb02954c1681d85?d=404&s=1024")));
 }
 
 void GravatarResolvUrlJobTest::shouldNotStart()
 {
     Gravatar::GravatarResolvUrlJob job;
     QVERIFY(!job.canStart());
 
     job.setEmail(QStringLiteral("foo"));
     QVERIFY(!job.canStart());
 
     job.setEmail(QStringLiteral(" "));
     QVERIFY(!job.canStart());
 
     job.setEmail(QStringLiteral("foo@kde.org"));
     QVERIFY(job.canStart());
 }
 
 void GravatarResolvUrlJobTest::shouldGenerateGravatarUrl_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<QString>("calculedhash");
     QTest::addColumn<QUrl>("output");
     QTest::addColumn<bool>("uselibravatar");
     QTest::newRow("empty") << QString() << QString() << QUrl() << false;
     QTest::newRow("no domain") << QStringLiteral("foo") << QString() << QUrl() << false;
     QTest::newRow("validemail") << QStringLiteral("foo@kde.org") << QStringLiteral("89b4e14cf2fc6d426275c019c6dc9de6")
                                 << QUrl(QStringLiteral("https://secure.gravatar.com:443/avatar/89b4e14cf2fc6d426275c019c6dc9de6?d=404")) << false;
     QTest::newRow("validemaillibravatar") << QStringLiteral("foo@kde.org") << QStringLiteral("2726400c3a33ce56c0ff632cbc0474f766d3b36e68819c601fb02954c1681d85")
                                           << QUrl(QStringLiteral("https://seccdn.libravatar.org:443/avatar/2726400c3a33ce56c0ff632cbc0474f766d3b36e68819c601fb02954c1681d85?d=404")) << true;
 }
 
 void GravatarResolvUrlJobTest::shouldGenerateGravatarUrl()
 {
     QFETCH(QString, input);
     QFETCH(QString, calculedhash);
     QFETCH(QUrl, output);
     QFETCH(bool, uselibravatar);
     Gravatar::GravatarResolvUrlJob job;
     job.setEmail(input);
     job.setUseLibravatar(uselibravatar);
     QUrl url = job.generateGravatarUrl(job.useLibravatar());
     QCOMPARE(calculedhash, job.calculatedHash());
     QCOMPARE(url, output);
 }
 
 QTEST_MAIN(GravatarResolvUrlJobTest)
diff --git a/src/job/gravatarresolvurljob.cpp b/src/job/gravatarresolvurljob.cpp
index ac72767..901e12c 100644
--- a/src/job/gravatarresolvurljob.cpp
+++ b/src/job/gravatarresolvurljob.cpp
@@ -1,275 +1,263 @@
 /*
    Copyright (c) 2015-2017 Laurent Montel <montel@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "gravatarresolvurljob.h"
 #include "misc/gravatarcache.h"
 #include "gravatar_debug.h"
 #include <PimCommon/NetworkManager>
 
 #include <QCoreApplication>
 #include <QCryptographicHash>
 #include <QPixmap>
 #include <QUrlQuery>
 #include <QNetworkConfigurationManager>
 
 using namespace Gravatar;
 
 class Gravatar::GravatarResolvUrlJobPrivate
 {
 public:
     GravatarResolvUrlJobPrivate()
         : mNetworkAccessManager(nullptr)
         , mSize(80)
         , mHasGravatar(false)
         , mUseDefaultPixmap(false)
-        , mUseCache(false)
         , mUseLibravatar(false)
         , mFallbackGravatar(true)
         , mFallbackDone(false)
     {
     }
 
     QPixmap mPixmap;
     QString mEmail;
     QString mCalculatedHash;
     QNetworkAccessManager *mNetworkAccessManager;
     int mSize;
     bool mHasGravatar;
     bool mUseDefaultPixmap;
-    bool mUseCache;
     bool mUseLibravatar;
     bool mFallbackGravatar;
     bool mFallbackDone;
 };
 
 GravatarResolvUrlJob::GravatarResolvUrlJob(QObject *parent)
     : QObject(parent)
     , d(new Gravatar::GravatarResolvUrlJobPrivate)
 {
 }
 
 GravatarResolvUrlJob::~GravatarResolvUrlJob()
 {
     delete d;
 }
 
 bool GravatarResolvUrlJob::canStart() const
 {
     if (PimCommon::NetworkManager::self()->networkConfigureManager()->isOnline()) {
         return !d->mEmail.trimmed().isEmpty() && (d->mEmail.contains(QLatin1Char('@')));
     } else {
         return false;
     }
 }
 
 QUrl GravatarResolvUrlJob::generateGravatarUrl(bool useLibravatar)
 {
     return createUrl(useLibravatar);
 }
 
 bool GravatarResolvUrlJob::hasGravatar() const
 {
     return d->mHasGravatar;
 }
 
 void GravatarResolvUrlJob::startNetworkManager(const QUrl &url)
 {
     if (PimCommon::NetworkManager::self()->networkConfigureManager()->isOnline()) {
         if (!d->mNetworkAccessManager) {
             d->mNetworkAccessManager = new QNetworkAccessManager(this);
             connect(d->mNetworkAccessManager, &QNetworkAccessManager::finished, this, &GravatarResolvUrlJob::slotFinishLoadPixmap);
         }
         QNetworkReply *reply = d->mNetworkAccessManager->get(QNetworkRequest(url));
         connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(slotError(QNetworkReply::NetworkError)));
     } else {
         qCDebug(GRAVATAR_LOG) << " network is not connected";
         deleteLater();
         return;
     }
 }
 
 void GravatarResolvUrlJob::start()
 {
     d->mHasGravatar = false;
     d->mFallbackDone = false;
     if (canStart()) {
         d->mCalculatedHash.clear();
         const QUrl url = createUrl(d->mUseLibravatar);
         Q_EMIT resolvUrl(url);
         if (!cacheLookup(d->mCalculatedHash))
             startNetworkManager(url);
     } else {
         qCDebug(GRAVATAR_LOG) << "Gravatar can not start";
         deleteLater();
     }
 }
 
 void GravatarResolvUrlJob::slotFinishLoadPixmap(QNetworkReply *reply)
 {
     if (reply->error() == QNetworkReply::NoError) {
         d->mPixmap.loadFromData(reply->readAll());
         d->mHasGravatar = true;
         //For the moment don't use cache other we will store a lot of pixmap
         if (!d->mUseDefaultPixmap) {
             GravatarCache::self()->saveGravatarPixmap(d->mCalculatedHash, d->mPixmap);
         }
     } else if (d->mUseLibravatar && d->mFallbackGravatar && !d->mFallbackDone) {
         d->mFallbackDone = true;
         d->mCalculatedHash.clear();
         const QUrl url = createUrl(false);
         Q_EMIT resolvUrl(url);
         if (!cacheLookup(d->mCalculatedHash))
             startNetworkManager(url);
         return;
     }
     reply->deleteLater();
     Q_EMIT finished(this);
     deleteLater();
 }
 
 void GravatarResolvUrlJob::slotError(QNetworkReply::NetworkError error)
 {
     if (error == QNetworkReply::ContentNotFoundError) {
         d->mHasGravatar = false;
     }
 }
 
 QString GravatarResolvUrlJob::email() const
 {
     return d->mEmail;
 }
 
 void GravatarResolvUrlJob::setEmail(const QString &email)
 {
     d->mEmail = email;
 }
 
 QString GravatarResolvUrlJob::calculateHash(bool useLibravator)
 {
     QCryptographicHash hash(useLibravator ? QCryptographicHash::Sha256 : QCryptographicHash::Md5);
     hash.addData(d->mEmail.toLower().toUtf8());
     return QString::fromUtf8(hash.result().toHex());
 }
 
 bool GravatarResolvUrlJob::fallbackGravatar() const
 {
     return d->mFallbackGravatar;
 }
 
 void GravatarResolvUrlJob::setFallbackGravatar(bool fallbackGravatar)
 {
     d->mFallbackGravatar = fallbackGravatar;
 }
 
 bool GravatarResolvUrlJob::useLibravatar() const
 {
     return d->mUseLibravatar;
 }
 
 void GravatarResolvUrlJob::setUseLibravatar(bool useLibravatar)
 {
     d->mUseLibravatar = useLibravatar;
 }
 
-bool GravatarResolvUrlJob::useCache() const
-{
-    return d->mUseCache;
-}
-
-void GravatarResolvUrlJob::setUseCache(bool useCache)
-{
-    d->mUseCache = useCache;
-}
-
 bool GravatarResolvUrlJob::useDefaultPixmap() const
 {
     return d->mUseDefaultPixmap;
 }
 
 void GravatarResolvUrlJob::setUseDefaultPixmap(bool useDefaultPixmap)
 {
     d->mUseDefaultPixmap = useDefaultPixmap;
 }
 
 int GravatarResolvUrlJob::size() const
 {
     return d->mSize;
 }
 
 QPixmap GravatarResolvUrlJob::pixmap() const
 {
     return d->mPixmap;
 }
 
 void GravatarResolvUrlJob::setSize(int size)
 {
     if (size <= 0) {
         size = 80;
     } else if (size > 2048) {
         size = 2048;
     }
     d->mSize = size;
 }
 
 QString GravatarResolvUrlJob::calculatedHash() const
 {
     return d->mCalculatedHash;
 }
 
 QUrl GravatarResolvUrlJob::createUrl(bool useLibravatar)
 {
     QUrl url;
     d->mCalculatedHash.clear();
     if (!canStart()) {
         return url;
     }
     QUrlQuery query;
     if (!d->mUseDefaultPixmap) {
         //Add ?d=404
         query.addQueryItem(QStringLiteral("d"), QStringLiteral("404"));
     }
     if (d->mSize != 80) {
         query.addQueryItem(QStringLiteral("s"), QString::number(d->mSize));
     }
     url.setScheme(QStringLiteral("https"));
     if (useLibravatar) {
         url.setHost(QStringLiteral("seccdn.libravatar.org"));
     } else {
         url.setHost(QStringLiteral("secure.gravatar.com"));
     }
     url.setPort(443);
     d->mCalculatedHash = calculateHash(useLibravatar);
     url.setPath(QLatin1String("/avatar/") + d->mCalculatedHash);
     url.setQuery(query);
     return url;
 }
 
 bool GravatarResolvUrlJob::cacheLookup(const QString &hash)
 {
     bool haveStoredPixmap = false;
     const QPixmap pix = GravatarCache::self()->loadGravatarPixmap(hash, haveStoredPixmap);
     if (haveStoredPixmap && !pix.isNull()) {
         d->mPixmap = pix;
         d->mHasGravatar = true;
         Q_EMIT finished(this);
         deleteLater();
         return true;
     }
     return false;
 }
diff --git a/src/job/gravatarresolvurljob.h b/src/job/gravatarresolvurljob.h
index b9b8841..a836843 100644
--- a/src/job/gravatarresolvurljob.h
+++ b/src/job/gravatarresolvurljob.h
@@ -1,84 +1,81 @@
 /*
    Copyright (C) 2015-2017 Laurent Montel <montel@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef GRAVATARRESOLVURLJOB_H
 #define GRAVATARRESOLVURLJOB_H
 
 #include "gravatar_export.h"
 #include <QObject>
 #include <QUrl>
 #include <QPixmap>
 #include <QNetworkReply>
 namespace Gravatar {
 class GravatarResolvUrlJobPrivate;
 class GRAVATAR_EXPORT GravatarResolvUrlJob : public QObject
 {
     Q_OBJECT
 public:
     explicit GravatarResolvUrlJob(QObject *parent = nullptr);
     ~GravatarResolvUrlJob();
 
     bool canStart() const;
     void start();
 
     QString email() const;
     void setEmail(const QString &email);
 
     QUrl generateGravatarUrl(bool useLibravatar);
 
     bool hasGravatar() const;
 
     QString calculatedHash() const;
 
     void setSize(int size);
 
     int size() const;
 
     QPixmap pixmap() const;
 
     bool useDefaultPixmap() const;
     void setUseDefaultPixmap(bool useDefaultPixmap);
 
-    bool useCache() const;
-    void setUseCache(bool useCache);
-
     bool useLibravatar() const;
     void setUseLibravatar(bool useLibravatar);
 
     bool fallbackGravatar() const;
     void setFallbackGravatar(bool fallbackGravatar);
 
 Q_SIGNALS:
     void finished(Gravatar::GravatarResolvUrlJob *);
     void resolvUrl(const QUrl &url);
 
 private Q_SLOTS:
     void slotFinishLoadPixmap(QNetworkReply *reply);
     void slotError(QNetworkReply::NetworkError error);
 
 private:
     void startNetworkManager(const QUrl &url);
     QUrl createUrl(bool useLibravatar);
     QString calculateHash(bool useLibravator);
     bool cacheLookup(const QString &hash);
     GravatarResolvUrlJobPrivate *const d;
 };
 }
 
 #endif // GRAVATARRESOLVURLJOB_H