Merge lp:~mandel/ubuntu-download-manager/abstract-classes into lp:ubuntu-download-manager

[Manuel de la Peña]

Provide pure abstract classes to simplify testing.

Provide pure abstract classes to simplify testing.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:239
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/342/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/231
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/231

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/342/rebuild

review: Approve (continuous-integration)

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[lp:~mandel/ubuntu-download-manager/abstract-classes]

240. By Manuel de la Peña on 2014-02-19

Merged with auth signals to fix conflict.s

241. By Manuel de la Peña on 2014-02-19

Fixed compiling errors.

242. By Manuel de la Peña on 2014-02-19

Registered missing types.

=== modified file 'debian/libubuntu-download-manager-common-dev.install'
--- debian/libubuntu-download-manager-common-dev.install	2014-02-10 18:04:03 +0000
+++ debian/libubuntu-download-manager-common-dev.install	2014-02-19 18:29:41 +0000
@@ -2,6 +2,7 @@
 usr/include/ubuntu/download_manager/metatypes.h
 usr/include/ubuntu/download_manager/download_struct.h
 usr/include/ubuntu/download_manager/group_download_struct.h
+usr/include/ubuntu/download_manager/auth_error_struct.h
 usr/include/ubuntu/download_manager/http_error_struct.h
 usr/include/ubuntu/download_manager/network_error_struct.h
 usr/include/ubuntu/download_manager/process_error_struct.h

=== modified file 'docs/com.canonical.applications.download.xml'
--- docs/com.canonical.applications.download.xml	2014-01-27 16:36:44 +0000
+++ docs/com.canonical.applications.download.xml	2014-02-19 18:29:41 +0000
@@ -59,6 +59,11 @@
         <arg name="error" type="s" direction="out"/>
     </signal>
 
+    <signal name="authError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="AuthErrorStruct"/>
+        <arg name="error" type="(is)" direction="out"/>
+    </signal>
+
     <signal name="httpError">
         <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="HttpErrorStruct"/>
         <arg name="error" type="(is)" direction="out"/>

=== modified file 'docs/com.canonical.applications.group_download.xml'
--- docs/com.canonical.applications.group_download.xml	2013-12-03 13:03:53 +0000
+++ docs/com.canonical.applications.group_download.xml	2014-02-19 18:29:41 +0000
@@ -62,6 +62,30 @@
         <arg name="error" type="s" direction="out"/>
     </signal>
 
+    <signal name="authError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="AuthErrorStruct"/>
+        <arg name="url" type="s" direction="out"/>
+        <arg name="error" type="(is)" direction="out"/>
+    </signal>
+
+    <signal name="httpError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="HttpErrorStruct"/>
+        <arg name="url" type="s" direction="out"/>
+        <arg name="error" type="(is)" direction="out"/>
+    </signal>
+
+    <signal name="networkError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="NetworkErrorStruct"/>
+        <arg name="url" type="s" direction="out"/>
+        <arg name="error" type="(is)" direction="out"/>
+    </signal>
+
+    <signal name="processError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="ProcessErrorStruct"/>
+        <arg name="url" type="s" direction="out"/>
+        <arg name="error" type="(isiss)" direction="out"/>
+    </signal>
+
     <signal name="progress">
         <arg name="received" type="t" direction="out"/>
         <arg name="total" type="t" direction="out"/>

=== modified file 'docs/com.canonical.applications.testing.download_manager.xml'
--- docs/com.canonical.applications.testing.download_manager.xml	2014-02-03 17:48:28 +0000
+++ docs/com.canonical.applications.testing.download_manager.xml	2014-02-19 18:29:41 +0000
@@ -23,5 +23,10 @@
         <arg name="error" type="(isiss)" direction="in"/>
     </method>
 
+    <method name="returnAuthError">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="AuthErrorStruct"/>
+        <arg name="download" type="s" direction="in"/>
+        <arg name="error" type="(is)" direction="in"/>
+    </method>
  </interface>
 </node>

=== modified file 'ubuntu-download-manager-client-tests/test_download.cpp'
--- ubuntu-download-manager-client-tests/test_download.cpp	2014-02-05 12:58:09 +0000
+++ ubuntu-download-manager-client-tests/test_download.cpp	2014-02-19 18:29:41 +0000
@@ -16,6 +16,7 @@
  * Boston, MA 02110-1301, USA.
  */
 
+#include <QNetworkReply>
 #include <QSignalSpy>
 #include <ubuntu/download_manager/error.h>
 #include "test_download.h"
@@ -137,6 +138,40 @@
 }
 
 void
+TestDownload::testAuthErrorRaised_data() {
+    QTest::addColumn<QNetworkReply::NetworkError>("code");
+    QTest::addColumn<QString>("msg");
+
+    QTest::newRow("Server Authentication")
+        << QNetworkReply::AuthenticationRequiredError
+        << "Server rejected request";
+    QTest::newRow("Proxy Authentication")
+        << QNetworkReply::ProxyAuthenticationRequiredError
+        << "Proxy rejected request";
+}
+
+void
+TestDownload::testAuthErrorRaised() {
+    QFETCH(QNetworkReply::NetworkError, code);
+    QFETCH(QString, msg);
+
+    AuthErrorStruct err(code, msg);
+    returnAuthError(_url, err);
+
+    QSignalSpy spy(_down, SIGNAL(error(Error*)));
+    _down->start();
+
+    QTRY_COMPARE(1, spy.count());
+    auto error = spy.takeFirst().at(0).value<Error*>();
+    QVERIFY(_down->isError());
+    QVERIFY(_down->error() != nullptr);
+    QCOMPARE(Error::Auth, error->type());
+
+    auto authError = qobject_cast<AuthError*>(error);
+    QCOMPARE(msg, authError->phrase());
+}
+
+void
 TestDownload::testHttpErrorRaised_data() {
     QTest::addColumn<int>("code");
     QTest::addColumn<QString>("msg");

=== modified file 'ubuntu-download-manager-client-tests/test_download.h'
--- ubuntu-download-manager-client-tests/test_download.h	2014-02-05 11:01:12 +0000
+++ ubuntu-download-manager-client-tests/test_download.h	2014-02-19 18:29:41 +0000
@@ -47,6 +47,8 @@
     void testMetadataError();
     void testProgressError();
     void testTotalSizeError();
+    void testAuthErrorRaised_data();
+    void testAuthErrorRaised();
     void testHttpErrorRaised_data();
     void testHttpErrorRaised();
     void testNetworkErroRaised_data();

=== modified file 'ubuntu-download-manager-client/ubuntu-download-manager-client.pro'
--- ubuntu-download-manager-client/ubuntu-download-manager-client.pro	2014-02-07 10:06:24 +0000
+++ ubuntu-download-manager-client/ubuntu-download-manager-client.pro	2014-02-19 18:29:41 +0000
@@ -10,9 +10,10 @@
 DEFINES += UBUNTUDOWNLOADMANAGERCLIENT_LIBRARY
 
 SOURCES += ubuntu/download_manager/manager.cpp \
+           ubuntu/download_manager/manager_impl.cpp \
            ubuntu/download_manager/download_interface.cpp \
            ubuntu/download_manager/manager_interface.cpp \
-           ubuntu/download_manager/download.cpp \
+           ubuntu/download_manager/download_impl.cpp \
            ubuntu/download_manager/group_download.cpp \
            ubuntu/download_manager/manager_pendingcall_watcher.cpp \
            ubuntu/download_manager/error.cpp \
@@ -26,6 +27,8 @@
     ubuntu/download_manager/error.h
 
 private_headers = \
+    ubuntu/download_manager/manager_impl.h \
+    ubuntu/download_manager/download_impl.h \
     ubuntu/download_manager/download_interface.h \
     ubuntu/download_manager/manager_interface.h \
     ubuntu/download_manager/manager_pendingcall_watcher.h \

=== added file 'ubuntu-download-manager-client/ubuntu/download_manager/download.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/download.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/download.h	2014-02-19 18:29:41 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2013-2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H
+#define UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H
+
+#include <QObject>
+#include <QVariantMap>
+#include <QString>
+#include <ubuntu/download_manager/common.h>
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+class Error;
+class DOWNLOAD_MANAGER_EXPORT Download : public QObject {
+    Q_OBJECT
+
+ public:
+    explicit Download(QObject* parent = 0)
+        : QObject(parent) {}
+
+    virtual void start() = 0;
+    virtual void pause() = 0;
+    virtual void resume() = 0;
+    virtual void cancel() = 0;
+
+    virtual void allowMobileDownload(bool allowed) = 0;
+    virtual bool isMobileDownloadAllowed() = 0;
+
+    virtual void setThrottle(qulonglong speed) = 0;
+    virtual qulonglong throttle() = 0;
+
+    virtual QString id() const = 0;
+    virtual QVariantMap metadata() = 0;
+    virtual qulonglong progress() = 0;
+    virtual qulonglong totalSize() = 0;
+
+    virtual bool isError() const = 0;
+    virtual Error* error() const = 0;
+
+ signals:
+    void canceled(bool success);
+    void error(Error* error);
+    void finished(const QString& path);
+    void paused(bool success);
+    void processing(const QString &path);
+    void progress(qulonglong received, qulonglong total);
+    void resumed(bool success);
+    void started(bool success);
+
+};
+
+}  // Ubuntu
+
+}  // DownloadManager
+
+#endif  // UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H

=== renamed file 'ubuntu-download-manager-client/ubuntu/download_manager/download.cpp' => 'ubuntu-download-manager-client/ubuntu/download_manager/download_impl.cpp'
--- ubuntu-download-manager-client/ubuntu/download_manager/download.cpp	2014-02-05 11:01:12 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/download_impl.cpp	2014-02-19 18:29:41 +0000
@@ -16,365 +16,253 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <QDebug>
-#include <QDBusConnection>
-#include <QDBusObjectPath>
-#include <ubuntu/download_manager/metatypes.h>
-#include "download_pendingcall_watcher.h"
-#include "download_interface.h"
-#include "error.h"
-#include "download.h"
+#include "download_impl.h"
 
 namespace Ubuntu {
 
 namespace DownloadManager {
 
-/*
- * PRIVATE IMPLEMENTATION
- */
-
-class DownloadPrivate {
-    Q_DECLARE_PUBLIC(Download)
-
- public:
-    DownloadPrivate(const QDBusConnection& conn,
-                    const QString& servicePath,
-                    const QDBusObjectPath& objectPath,
-                    Download* parent)
-        : _id(objectPath.path()),
-          _conn(conn),
-          _servicePath(servicePath),
-          q_ptr(parent) {
-        Q_Q(Download);
-        _dbusInterface = new DownloadInterface(servicePath,
-            _id, conn);
-
-        // fwd all the signals but the error one
-        q->connect(_dbusInterface, &DownloadInterface::canceled,
-            q, &Download::canceled);
-        q->connect(_dbusInterface, &DownloadInterface::finished,
-            q, &Download::finished);
-        q->connect(_dbusInterface, &DownloadInterface::paused,
-            q, &Download::paused);
-        q->connect(_dbusInterface, &DownloadInterface::processing,
-            q, &Download::processing);
-        q->connect(_dbusInterface, static_cast<void(DownloadInterface::*)
-            (qulonglong, qulonglong)>(&DownloadInterface::progress),
-            q, static_cast<void(Download::*)
-                (qulonglong, qulonglong)>(&Download::progress));
-        q->connect(_dbusInterface, &DownloadInterface::resumed,
-            q, &Download::resumed);
-        q->connect(_dbusInterface, &DownloadInterface::started,
-            q, &Download::started);
-
-        // connect to the different type of errors that will later be converted to
-        // the error type to be used by the client. With a pimpl implementation we
-        // cannot use the new stype connections :(
-        q->connect(_dbusInterface, SIGNAL(httpError(HttpErrorStruct)),
-            q, SLOT(onHttpError(HttpErrorStruct)));
-        q->connect(_dbusInterface, SIGNAL(networkError(NetworkErrorStruct)),
-            q, SLOT(onNetworkError(NetworkErrorStruct)));
-        q->connect(_dbusInterface, SIGNAL(processError(ProcessErrorStruct)),
-            q, SLOT(onProcessError(ProcessErrorStruct)));
-    }
-
-    DownloadPrivate(const QDBusConnection& conn, Error* err, Download* parent)
-        : _isError(true),
-          _lastError(err),
-          _conn(conn),
-          q_ptr(parent) {
-    }
-
-    ~DownloadPrivate() {
+DownloadImpl::DownloadImpl(const QDBusConnection& conn,
+                           const QString& servicePath,
+                           const QDBusObjectPath& objectPath,
+                           QObject* parent)
+    : Download(parent),
+      _id(objectPath.path()),
+      _conn(conn),
+      _servicePath(servicePath) {
+    _dbusInterface = new DownloadInterface(servicePath,
+        _id, conn);
+
+    // fwd all the signals but the error one
+    connect(_dbusInterface, &DownloadInterface::canceled,
+        this, &Download::canceled);
+    connect(_dbusInterface, &DownloadInterface::finished,
+        this, &Download::finished);
+    connect(_dbusInterface, &DownloadInterface::paused,
+        this, &Download::paused);
+    connect(_dbusInterface, &DownloadInterface::processing,
+        this, &Download::processing);
+    connect(_dbusInterface, static_cast<void(DownloadInterface::*)
+        (qulonglong, qulonglong)>(&DownloadInterface::progress),
+        this, static_cast<void(Download::*)
+            (qulonglong, qulonglong)>(&Download::progress));
+    connect(_dbusInterface, &DownloadInterface::resumed,
+        this, &Download::resumed);
+    connect(_dbusInterface, &DownloadInterface::started,
+        this, &Download::started);
+
+    // connect to the different type of errors that will later be converted to
+    // the error type to be used by the client.
+    connect(_dbusInterface, &DownloadInterface::httpError,
+        this, &DownloadImpl::onHttpError);
+    connect(_dbusInterface, &DownloadInterface::networkError,
+        this, &DownloadImpl::onNetworkError);
+    connect(_dbusInterface, &DownloadInterface::processError,
+        this, &DownloadImpl::onProcessError);
+    connect(_dbusInterface, &DownloadInterface::authError,
+        this, &DownloadImpl::onAuthError);
+}
+
+DownloadImpl::DownloadImpl(const QDBusConnection& conn, Error* err, QObject* parent)
+    : Download(parent),
+      _isError(true),
+      _lastError(err),
+      _conn(conn) {
+}
+
+DownloadImpl::~DownloadImpl() {
+    delete _lastError;
+    delete _dbusInterface;
+}
+
+void
+DownloadImpl::setLastError(Error* err) {
+    if (_lastError != nullptr) {
         delete _lastError;
-        delete _dbusInterface;
-    }
-
-    void setLastError(Error* err) {
-        Q_Q(Download);
-        if (_lastError != nullptr) {
-            delete _lastError;
-        }
-        _lastError = err;
-        _isError = true;
-        emit q->error(err);
-    }
-
-    void setLastError(const QDBusError& err) {
-        Q_Q(Download);
-        setLastError(new DBusError(err, q));
-    }
-
-    void start() {
-        Q_Q(Download);
-        QDBusPendingCall call =
-            _dbusInterface->start();
-        auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
-            call, q);
-        Q_UNUSED(watcher);
-    }
-
-    void pause() {
-        Q_Q(Download);
-        QDBusPendingCall call =
-            _dbusInterface->pause();
-        auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
-            call, q);
-        Q_UNUSED(watcher);
-    }
-
-    void resume() {
-        Q_Q(Download);
-        QDBusPendingCall call =
-            _dbusInterface->resume();
-        auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
-            call, q);
-        Q_UNUSED(watcher);
-    }
-
-    void cancel() {
-        Q_Q(Download);
-        QDBusPendingCall call =
-            _dbusInterface->cancel();
-        auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
-            call, q);
-        Q_UNUSED(watcher);
-    }
-
-    void allowMobileDownload(bool allowed) {
-        QDBusPendingReply<> reply =
-            _dbusInterface->allowGSMDownload(allowed);
-        // block, the call should be fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-        }
-    }
-
-    bool isMobileDownloadAllowed() {
-        QDBusPendingReply<bool> reply =
-            _dbusInterface->isGSMDownloadAllowed();
-        // block, the call should be fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-            return false;
-        } else {
-            auto result = reply.value();
-            return result;
-        }
-    }
-
-    void setThrottle(qulonglong speed) {
-        QDBusPendingReply<> reply =
-            _dbusInterface->setThrottle(speed);
-        // block, the call should be fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-        }
-    }
-
-    qulonglong throttle() {
-        QDBusPendingReply<qulonglong> reply =
-            _dbusInterface->throttle();
-        // block, the call is fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-            return 0;
-        } else {
-            auto result = reply.value();
-            return result;
-        }
-    }
-
-    QString id() {
-        return _id;
-    }
-
-    QVariantMap metadata() {
-        QDBusPendingReply<QVariantMap> reply =
-            _dbusInterface->metadata();
-        // block the call is fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            QVariantMap emptyResult;
-            setLastError(reply.error());
-            return emptyResult;
-        } else {
-            auto result = reply.value();
-            return result;
-        }
-    }
-
-    qulonglong progress() {
-        QDBusPendingReply<qulonglong> reply =
-            _dbusInterface->progress();
-        // block call should be fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-            return 0;
-        } else {
-            auto result = reply.value();
-            return result;
-        }
-    }
-
-    qulonglong totalSize() {
-        QDBusPendingReply<qulonglong> reply =
-            _dbusInterface->totalSize();
-        // block call should b fast enough
-        reply.waitForFinished();
-        if (reply.isError()) {
-            setLastError(reply.error());
-            return 0;
-        } else {
-            auto result = reply.value();
-            return result;
-        }
-    }
-
-    bool isError() {
-        return _isError;
-    }
-
-    Error* error() {
-        return _lastError;
-    }
-
-    void onHttpError(HttpErrorStruct errStruct) {
-        Q_Q(Download);
-        auto err = new HttpError(errStruct, q);
-        setLastError(err);
-    }
-
-    void onNetworkError(NetworkErrorStruct errStruct) {
-        Q_Q(Download);
-        auto err = new NetworkError(errStruct, q);
-        setLastError(err);
-    }
-
-    void onProcessError(ProcessErrorStruct errStruct) {
-        Q_Q(Download);
-        auto err = new ProcessError(errStruct, q);
-        setLastError(err);
-    }
-
- private:
-    QString _id;
-    bool _isError = false;
-    Error* _lastError = nullptr;
-    DownloadInterface* _dbusInterface = nullptr;
-    QDBusConnection _conn;
-    QString _servicePath;
-    Download* q_ptr;
-};
-
-Download::Download(const QDBusConnection& conn, Error* err, QObject* parent)
-    : QObject(parent),
-      d_ptr(new DownloadPrivate(conn, err, this)) {
-}
-
-Download::Download(const QDBusConnection& conn,
-                   const QString& servicePath,
-                   const QDBusObjectPath& objectPath,
-                   QObject* parent)
-    : QObject(parent),
-      d_ptr(new DownloadPrivate(conn, servicePath, objectPath, this)) {
-}
-
-Download::~Download() {
-    delete d_ptr;
-}
-
-void
-Download::start(){
-    Q_D(Download);
-    d->start();
-}
-
-void
-Download::pause(){
-    Q_D(Download);
-    d->pause();
-}
-
-void
-Download::resume(){
-    Q_D(Download);
-    d->resume();
-}
-
-void
-Download::cancel(){
-    Q_D(Download);
-    d->cancel();
-}
-
-void
-Download::allowMobileDownload(bool allowed){
-    Q_D(Download);
-    d->allowMobileDownload(allowed);
+    }
+    _lastError = err;
+    _isError = true;
+    emit Download::error(err);
+}
+
+void
+DownloadImpl::setLastError(const QDBusError& err) {
+    setLastError(new DBusError(err, this));
+}
+
+void
+DownloadImpl::start() {
+    QDBusPendingCall call =
+        _dbusInterface->start();
+    auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
+        call, this);
+    Q_UNUSED(watcher);
+}
+
+void
+DownloadImpl::pause() {
+    QDBusPendingCall call =
+        _dbusInterface->pause();
+    auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
+        call, this);
+    Q_UNUSED(watcher);
+}
+
+void
+DownloadImpl::resume() {
+    QDBusPendingCall call =
+        _dbusInterface->resume();
+    auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
+        call, this);
+    Q_UNUSED(watcher);
+}
+
+void
+DownloadImpl::cancel() {
+    QDBusPendingCall call =
+        _dbusInterface->cancel();
+    auto watcher = new DownloadPendingCallWatcher(_conn, _servicePath,
+        call, this);
+    Q_UNUSED(watcher);
+}
+
+void
+DownloadImpl::allowMobileDownload(bool allowed) {
+    QDBusPendingReply<> reply =
+        _dbusInterface->allowGSMDownload(allowed);
+    // block, the call should be fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+    }
 }
 
 bool
-Download::isMobileDownloadAllowed(){
-    Q_D(Download);
-    return d->isMobileDownloadAllowed();
+DownloadImpl::isMobileDownloadAllowed() {
+    QDBusPendingReply<bool> reply =
+        _dbusInterface->isGSMDownloadAllowed();
+    // block, the call should be fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+        return false;
+    } else {
+        auto result = reply.value();
+        return result;
+    }
 }
 
 void
-Download::setThrottle(qulonglong speed){
-    Q_D(Download);
-    d->setThrottle(speed);
+DownloadImpl::setThrottle(qulonglong speed) {
+    QDBusPendingReply<> reply =
+        _dbusInterface->setThrottle(speed);
+    // block, the call should be fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+    }
 }
 
 qulonglong
-Download::throttle(){
-    Q_D(Download);
-    return d->throttle();
+DownloadImpl::throttle() {
+    QDBusPendingReply<qulonglong> reply =
+        _dbusInterface->throttle();
+    // block, the call is fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+        return 0;
+    } else {
+        auto result = reply.value();
+        return result;
+    }
 }
 
 QString
-Download::id() {
-    Q_D(Download);
-    return d->id();
+DownloadImpl::id() const {
+    return _id;
 }
 
 QVariantMap
-Download::metadata(){
-    Q_D(Download);
-    return d->metadata();
-}
-
-qulonglong
-Download::progress(){
-    Q_D(Download);
-    return d->progress();
-}
-
-qulonglong
-Download::totalSize(){
-    Q_D(Download);
-    return d->totalSize();
+DownloadImpl::metadata() {
+    QDBusPendingReply<QVariantMap> reply =
+        _dbusInterface->metadata();
+    // block the call is fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        QVariantMap emptyResult;
+        setLastError(reply.error());
+        return emptyResult;
+    } else {
+        auto result = reply.value();
+        return result;
+    }
+}
+
+qulonglong
+DownloadImpl::progress() {
+    QDBusPendingReply<qulonglong> reply =
+        _dbusInterface->progress();
+    // block call should be fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+        return 0;
+    } else {
+        auto result = reply.value();
+        return result;
+    }
+}
+
+qulonglong
+DownloadImpl::totalSize() {
+    QDBusPendingReply<qulonglong> reply =
+        _dbusInterface->totalSize();
+    // block call should b fast enough
+    reply.waitForFinished();
+    if (reply.isError()) {
+        setLastError(reply.error());
+        return 0;
+    } else {
+        auto result = reply.value();
+        return result;
+    }
 }
 
 bool
-Download::isError() {
-    Q_D(Download);
-    return d->isError();
+DownloadImpl::isError() const {
+    return _isError;
 }
 
 Error*
-Download::error() {
-    Q_D(Download);
-    return d->error();
+DownloadImpl::error() const {
+    return _lastError;
+}
+
+void
+DownloadImpl::onHttpError(HttpErrorStruct errStruct) {
+    auto err = new HttpError(errStruct, this);
+    setLastError(err);
+}
+
+void
+DownloadImpl::onNetworkError(NetworkErrorStruct errStruct) {
+    auto err = new NetworkError(errStruct, this);
+    setLastError(err);
+}
+
+void
+DownloadImpl::onProcessError(ProcessErrorStruct errStruct) {
+    auto err = new ProcessError(errStruct, this);
+    setLastError(err);
+}
+
+void
+DownloadImpl::onAuthError(AuthErrorStruct errStruct) {
+    auto err = new AuthError(errStruct, this);
+    setLastError(err);
 }
 
 }  // DownloadManager
 
 }  // Ubuntu
-
-#include "moc_download.cpp"

=== renamed file 'ubuntu-download-manager-client/ubuntu/download_manager/download.h' => 'ubuntu-download-manager-client/ubuntu/download_manager/download_impl.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/download.h	2014-02-07 10:06:24 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/download_impl.h	2014-02-19 18:29:41 +0000
@@ -16,13 +16,20 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H
-#define UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H
+#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_IMPL_H
+#define UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_IMPL_H
 
+#include <QDBusConnection>
+#include <QDBusObjectPath>
 #include <QObject>
 #include <QVariantMap>
 #include <QString>
 #include <ubuntu/download_manager/common.h>
+#include <ubuntu/download_manager/metatypes.h>
+#include "download_interface.h"
+#include "download_pendingcall_watcher.h"
+#include "error.h"
+#include "download.h"
 
 class QDBusConnection;
 class QDBusObjectPath;
@@ -36,10 +43,8 @@
 class NetworkErrorStruct;
 class ProcessErrorStruct;
 class ManagerPrivate;
-class DownloadPrivate;
-class DOWNLOAD_MANAGER_EXPORT Download : public QObject {
+class DownloadImpl : public Download {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(Download)
 
     // allow the manager to create downloads
     friend class ManagerPrivate;
@@ -47,7 +52,7 @@
     friend class DownloadManagerPendingCallWatcher;
 
  public:
-    virtual ~Download();
+    virtual ~DownloadImpl();
 
     void start();
     void pause();
@@ -60,39 +65,36 @@
     void setThrottle(qulonglong speed);
     qulonglong throttle();
 
-    QString id();
+    QString id() const;
     QVariantMap metadata();
     qulonglong progress();
     qulonglong totalSize();
 
-    bool isError();
-    Error* error();
+    bool isError() const;
+    Error* error() const;
 
  protected:
-    Download(const QDBusConnection& conn, Error* err, QObject* parent = 0);
-    Download(const QDBusConnection& conn,
-             const QString& servicePath,
-             const QDBusObjectPath& objectPath,
-             QObject* parent = 0);
-
- private:
-    Q_PRIVATE_SLOT(d_func(), void onHttpError(HttpErrorStruct))
-    Q_PRIVATE_SLOT(d_func(), void onNetworkError(NetworkErrorStruct))
-    Q_PRIVATE_SLOT(d_func(), void onProcessError(ProcessErrorStruct))
-
- signals:
-    void canceled(bool success);
-    void error(Error* error);
-    void finished(const QString& path);
-    void paused(bool success);
-    void processing(const QString &path);
-    void progress(qulonglong received, qulonglong total);
-    void resumed(bool success);
-    void started(bool success);
-
- private:
-    // use pimpl pattern so that users do not have to be recompiled
-    DownloadPrivate* d_ptr;
+    DownloadImpl(const QDBusConnection& conn, Error* err, QObject* parent = 0);
+    DownloadImpl(const QDBusConnection& conn,
+                 const QString& servicePath,
+                 const QDBusObjectPath& objectPath,
+                 QObject* parent = 0);
+
+ private:
+    void setLastError(Error* err);
+    void setLastError(const QDBusError& err);
+    void onHttpError(HttpErrorStruct);
+    void onNetworkError(NetworkErrorStruct);
+    void onProcessError(ProcessErrorStruct);
+    void onAuthError(AuthErrorStruct);
+
+ private:
+    QString _id;
+    bool _isError = false;
+    Error* _lastError = nullptr;
+    DownloadInterface* _dbusInterface = nullptr;
+    QDBusConnection _conn;
+    QString _servicePath;
 
 };
 
@@ -100,4 +102,4 @@
 
 }  // DownloadManager
 
-#endif  // UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_H
+#endif  // UBUNTU_DOWNLOADMANAGER_CLIENT_DOWNLOAD_IMPL_H

=== modified file 'ubuntu-download-manager-client/ubuntu/download_manager/download_interface.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/download_interface.h	2014-02-03 17:48:28 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/download_interface.h	2014-02-19 18:29:41 +0000
@@ -8,8 +8,8 @@
  * Do not edit! All changes made to it will be lost.
  */
 
-#ifndef DOWNLOAD_INTERFACE_H_1391245617
-#define DOWNLOAD_INTERFACE_H_1391245617
+#ifndef DOWNLOAD_INTERFACE_H_1392136772
+#define DOWNLOAD_INTERFACE_H_1392136772
 
 #include <QtCore/QObject>
 #include <QtCore/QByteArray>
@@ -106,6 +106,7 @@
     }
 
 Q_SIGNALS: // SIGNALS
+    void authError(AuthErrorStruct error);
     void canceled(bool success);
     void error(const QString &error);
     void finished(const QString &path);

=== modified file 'ubuntu-download-manager-client/ubuntu/download_manager/error.cpp'
--- ubuntu-download-manager-client/ubuntu/download_manager/error.cpp	2014-02-10 17:05:14 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/error.cpp	2014-02-19 18:29:41 +0000
@@ -22,6 +22,7 @@
 
 namespace {
     const QString DBUS_ERROR_STRING = "DBusError: %1 - %2";
+    const QString AUTH_ERROR_STRING = "AuthError: %1 - %2";
     const QString HTTP_ERROR_STRING = "HttpError: %1 - %2";
     const QString NETWORK_ERROR_STRING = "NetworkError: %1 - %2";
     const QString PROCESS_ERROR_STRING = "ProcessError: %1 - %2\nExit code: %3\nStdout: %4\nStderr:%5";
@@ -94,6 +95,46 @@
     DBusError* q_ptr;
 };
 
+class AuthErrorPrivate {
+    Q_DECLARE_PUBLIC(AuthError)
+
+ public:
+    AuthErrorPrivate(AuthErrorStruct err, AuthError* parent)
+        : _err(err),
+          q_ptr(parent) {
+    }
+
+    inline AuthError::Type type() {
+        switch(_err.getType()) {
+            case AuthErrorStruct::Proxy:
+                return AuthError::Proxy;
+            default:
+                return AuthError::Server;
+        }
+    }
+
+    inline QString getTypeString() {
+        switch(_err.getType()) {
+            case AuthErrorStruct::Proxy:
+                return "Proxy";
+            default:
+                return "Server";
+        }
+    }
+
+    inline QString phrase() {
+        return _err.getPhrase();
+    }
+
+    inline QString errorString() {
+        return AUTH_ERROR_STRING.arg(getTypeString(), _err.getPhrase());
+    }
+
+ private:
+    AuthErrorStruct _err;
+    AuthError* q_ptr;
+};
+
 class HttpErrorPrivate {
     Q_DECLARE_PUBLIC(HttpError)
 
@@ -138,7 +179,7 @@
     inline QString phrase() {
         return _err.getPhrase();
     }
-    
+
     inline QString errorString() {
         return NETWORK_ERROR_STRING.arg(QString::number(_err.getCode()),
             _err.getPhrase());
@@ -242,6 +283,33 @@
     return d->errorString();
 }
 
+AuthError::AuthError(AuthErrorStruct err, QObject* parent)
+    : Error(Error::Auth, parent),
+      d_ptr(new AuthErrorPrivate(err, this)) {
+}
+
+AuthError::~AuthError() {
+    delete d_ptr;
+}
+
+AuthError::Type
+AuthError::type() {
+    Q_D(AuthError);
+    return d->type();
+}
+
+QString
+AuthError::phrase() {
+    Q_D(AuthError);
+    return d->phrase();
+}
+
+QString
+AuthError::errorString() {
+    Q_D(AuthError);
+    return d->errorString();
+}
+
 HttpError::HttpError(HttpErrorStruct err, QObject* parent)
     : Error(Error::Http, parent),
       d_ptr(new HttpErrorPrivate(err, this)) {

=== modified file 'ubuntu-download-manager-client/ubuntu/download_manager/error.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/error.h	2014-02-10 21:56:42 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/error.h	2014-02-19 18:29:41 +0000
@@ -29,6 +29,7 @@
 
 namespace DownloadManager {
 
+class AuthErrorStruct;
 class HttpErrorStruct;
 class NetworkErrorStruct;
 class ProcessErrorStruct;
@@ -39,6 +40,7 @@
 
  public:
     enum Type {
+        Auth,
         DBus,
         Http,
         Network,
@@ -64,8 +66,8 @@
     Q_OBJECT
     Q_DECLARE_PRIVATE(DBusError)
 
-    friend class ManagerPrivate;
-    friend class DownloadPrivate;
+    friend class ManagerImpl;
+    friend class DownloadImpl;
     friend class DownloadManagerPendingCallWatcher;
     friend class DownloadPendingCallWatcher;
     friend class GroupManagerPendingCallWatcher;
@@ -83,12 +85,38 @@
     DBusErrorPrivate* d_ptr;
 };
 
+class AuthErrorPrivate;
+class DOWNLOAD_MANAGER_EXPORT AuthError : public Error {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(AuthError)
+
+    friend class DownloadImpl;
+
+ public:
+    enum Type {
+        Server,
+        Proxy
+    };
+
+    virtual ~AuthError();
+    Type type();
+    QString phrase();
+    QString errorString() override;
+
+ protected:
+    AuthError(AuthErrorStruct err, QObject* parent);
+
+ private:
+    // use pimpl pattern so that users do not have to be recompiled
+    AuthErrorPrivate* d_ptr;
+};
+
 class HttpErrorPrivate;
 class DOWNLOAD_MANAGER_EXPORT HttpError : public Error {
     Q_OBJECT
     Q_DECLARE_PRIVATE(HttpError)
 
-    friend class DownloadPrivate;
+    friend class DownloadImpl;
 
  public:
     virtual ~HttpError();
@@ -109,7 +137,7 @@
     Q_OBJECT
     Q_DECLARE_PRIVATE(NetworkError)
 
-    friend class DownloadPrivate;
+    friend class DownloadImpl;
 
  public:
     enum ErrorCode {
@@ -158,7 +186,7 @@
     Q_OBJECT
     Q_DECLARE_PRIVATE(ProcessError)
 
-    friend class DownloadPrivate;
+    friend class DownloadImpl;
 
  public:
     virtual ~ProcessError();

=== added file 'ubuntu-download-manager-client/ubuntu/download_manager/manager.cpp'
--- ubuntu-download-manager-client/ubuntu/download_manager/manager.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/manager.cpp	2014-02-19 18:29:41 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2013-2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDebug>
+#include "manager_impl.h"
+#include "manager.h"
+
+namespace {
+    const QString DOWNLOAD_SERVICE = "com.canonical.applications.Downloader";
+}
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+Manager*
+Manager::createSessionManager(const QString& path, QObject* parent) {
+    if (path.isEmpty()) {
+        return new ManagerImpl(QDBusConnection::sessionBus(), DOWNLOAD_SERVICE, parent);
+    } else {
+        return new ManagerImpl(QDBusConnection::sessionBus(), path, parent);
+    }
+}
+
+Manager*
+Manager::createSystemManager(const QString& path, QObject* parent) {
+    if (path.isEmpty()) {
+        return new ManagerImpl(QDBusConnection::systemBus(), DOWNLOAD_SERVICE, parent);
+    } else {
+        return new ManagerImpl(QDBusConnection::systemBus(), path, parent);
+    }
+}
+
+
+}  // DownloadManager
+
+}  // Ubuntu

=== added file 'ubuntu-download-manager-client/ubuntu/download_manager/manager.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/manager.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/manager.h	2014-02-19 18:29:41 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2013-2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_H
+#define UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_H
+
+#include <functional>
+#include <QList>
+#include <QObject>
+#include <ubuntu/download_manager/metatypes.h>
+#include <ubuntu/download_manager/common.h>
+#include <ubuntu/download_manager/download_struct.h>
+#include <ubuntu/download_manager/group_download_struct.h>
+
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+class Download;
+class Error;
+class GroupDownload;
+
+typedef std::function<void(Download*)> DownloadCb;
+typedef std::function<void(GroupDownload*)> GroupCb;
+
+class DOWNLOAD_MANAGER_EXPORT Manager : public QObject {
+    Q_OBJECT
+
+ public:
+    explicit Manager(QObject* parent = 0)
+        : QObject(parent) {}
+
+    virtual void createDownload(DownloadStruct downStruct) = 0;
+    virtual void createDownload(DownloadStruct downStruct,
+                                DownloadCb cb,
+                                DownloadCb errCb) = 0;
+    virtual void createDownload(StructList downs,
+                                const QString &algorithm,
+                                bool allowed3G,
+                                const QVariantMap &metadata,
+                                StringMap headers) = 0;
+    virtual void createDownload(StructList downs,
+                                const QString &algorithm,
+                                bool allowed3G,
+                                const QVariantMap &metadata,
+                                StringMap headers,
+                                GroupCb cb,
+                                GroupCb errCb) = 0;
+
+    virtual bool isError() const = 0;
+    virtual Error* lastError() const = 0;
+    virtual void allowMobileDataDownload(bool allowed) = 0;
+    virtual bool isMobileDataDownload() = 0;
+    virtual qulonglong defaultThrottle() = 0;
+    virtual void setDefaultThrottle(qulonglong speed) = 0;
+    virtual void exit() = 0;
+
+    static Manager* createSessionManager(const QString& path = "", QObject* parent=0);
+    static Manager* createSystemManager(const QString& path = "", QObject* parent=0);
+
+ signals:
+    void downloadCreated(Download* down);
+    void groupCreated(GroupDownload* down);
+
+};
+
+}  // DownloadManager
+
+}  // Ubuntu
+
+#endif  // UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_H

=== renamed file 'ubuntu-download-manager-client/ubuntu/download_manager/manager.cpp' => 'ubuntu-download-manager-client/ubuntu/download_manager/manager_impl.cpp'
--- ubuntu-download-manager-client/ubuntu/download_manager/manager.cpp	2014-02-05 12:58:09 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/manager_impl.cpp	2014-02-19 18:29:41 +0000
@@ -17,359 +17,220 @@
  */
 
 #include <QDebug>
-#include <QDBusConnection>
-#include <QDBusObjectPath>
-#include <ubuntu/download_manager/system/dbus_connection.h>
-#include "download.h"
-#include "error.h"
-#include "group_download.h"
-#include "manager_interface.h"
-#include "manager_pendingcall_watcher.h"
-#include "manager.h"
-
-
-#define DOWNLOAD_SERVICE "com.canonical.applications.Downloader"
-#define MANAGER_PATH "/"
-
+#include "manager_impl.h"
+
+namespace {
+    const QString MANAGER_PATH = "/";
+}
 
 namespace Ubuntu {
 
 namespace DownloadManager {
 
-/*
- * PRIVATE IMPLEMENTATION
- */
-
-class ManagerPrivate {
-    Q_DECLARE_PUBLIC(Manager)
-
- public:
-    ManagerPrivate(const QDBusConnection& conn,
-                   const QString& path,
-                   Manager* parent)
-        : _conn(conn),
-          _servicePath(path),
-          q_ptr(parent) {
-        _dbusInterface = new ManagerInterface(path, MANAGER_PATH, conn);
-        init();
-    }
-
-    // used for testing purposes
-    ManagerPrivate(const QDBusConnection& conn,
-                   const QString& path,
-                   ManagerInterface* interface,
-                   Manager* parent)
-        : _conn(conn),
-          _servicePath(path),
-          _dbusInterface(interface),
-          q_ptr(parent) {
-        init();
-    }
-
-    ~ManagerPrivate() {
+ManagerImpl::ManagerImpl(const QDBusConnection& conn,
+                         const QString& path,
+                         QObject* parent)
+    : Manager(parent),
+      _conn(conn),
+      _servicePath(path) {
+    _dbusInterface = new ManagerInterface(path, MANAGER_PATH, conn);
+    init();
+}
+
+// used for testing purposes
+ManagerImpl::ManagerImpl(const QDBusConnection& conn,
+                         const QString& path,
+                         ManagerInterface* interface,
+                         QObject* parent)
+    : Manager(parent),
+      _conn(conn),
+      _servicePath(path),
+      _dbusInterface(interface) {
+    init();
+}
+
+ManagerImpl::~ManagerImpl() {
+    delete _lastError;
+    delete _dbusInterface;
+}
+
+void
+ManagerImpl::init() {
+    qRegisterMetaType<Download*>("Download*");
+    qRegisterMetaType<GroupDownload*>("GroupDownload*");
+    qRegisterMetaType<Error*>("Error*");
+    qRegisterMetaType<DBusError*>("DBusError*");
+    qRegisterMetaType<HttpError*>("HttpError*");
+    qRegisterMetaType<NetworkError*>("NetworkError*");
+    qRegisterMetaType<AuthError*>("AuthError*");
+    qRegisterMetaType<ProcessError*>("ProcessError*");
+    qDBusRegisterMetaType<StringMap>();
+    qDBusRegisterMetaType<DownloadStruct>();
+    qDBusRegisterMetaType<GroupDownloadStruct>();
+    qDBusRegisterMetaType<StructList>();
+    qDBusRegisterMetaType<AuthErrorStruct>();
+    qDBusRegisterMetaType<HttpErrorStruct>();
+    qDBusRegisterMetaType<NetworkErrorStruct>();
+    qDBusRegisterMetaType<ProcessErrorStruct>();
+}
+
+void
+ManagerImpl::createDownload(DownloadStruct downStruct) {
+    QDBusPendingCall call =
+        _dbusInterface->createDownload(downStruct);
+    DownloadCb cb = [](Download*) {};
+
+    auto watcher = new DownloadManagerPendingCallWatcher(_conn,
+            _servicePath, call, cb, cb, this);
+    connect(watcher, &DownloadManagerPendingCallWatcher::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+}
+
+void
+ManagerImpl::createDownload(DownloadStruct downStruct,
+                    DownloadCb cb,
+                    DownloadCb errCb) {
+    QDBusPendingCall call =
+        _dbusInterface->createDownload(downStruct);
+    auto watcher = new DownloadManagerPendingCallWatcher(_conn,
+            _servicePath, call, cb, errCb, this);
+    connect(watcher, &DownloadManagerPendingCallWatcher::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+}
+
+void
+ManagerImpl::createDownload(StructList downs,
+                    const QString& algorithm,
+                    bool allowed3G,
+                    const QVariantMap& metadata,
+                    StringMap headers) {
+    QDBusPendingCall call =
+        _dbusInterface->createDownloadGroup(downs,
+            algorithm, allowed3G, metadata, headers);
+
+    GroupCb cb = [](GroupDownload*) {};
+
+    auto watcher = new GroupManagerPendingCallWatcher(_conn, _servicePath,
+            call, cb, cb, this);
+    connect(watcher, &GroupManagerPendingCallWatcher::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+}
+
+void
+ManagerImpl::createDownload(StructList downs,
+                    const QString& algorithm,
+                    bool allowed3G,
+                    const QVariantMap& metadata,
+                    StringMap headers,
+                    GroupCb cb,
+                    GroupCb errCb) {
+    QDBusPendingCall call =
+        _dbusInterface->createDownloadGroup(downs,
+            algorithm, allowed3G, metadata, headers);
+    auto watcher = new GroupManagerPendingCallWatcher(_conn, _servicePath,
+            call, cb, errCb, this);
+    connect(watcher, &GroupManagerPendingCallWatcher::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+}
+
+bool
+ManagerImpl::isError() const {
+    return _isError;
+}
+
+Error*
+ManagerImpl::lastError() const {
+    return _lastError;
+}
+
+void
+ManagerImpl::setLastError(const QDBusError& err) {
+    // delete the last if error if present to keep mem to a minimum
+    if (_lastError != nullptr) {
         delete _lastError;
-        delete _dbusInterface;
-    }
-
-    void init() {
-        qRegisterMetaType<Download*>("Download*");
-        qRegisterMetaType<GroupDownload*>("GroupDownload*");
-        qRegisterMetaType<Error*>("Error*");
-        qRegisterMetaType<DBusError*>("DBusError*");
-        qRegisterMetaType<HttpError*>("HttpError*");
-        qRegisterMetaType<NetworkError*>("NetworkError*");
-        qRegisterMetaType<ProcessError*>("ProcessError*");
-        qDBusRegisterMetaType<StringMap>();
-        qDBusRegisterMetaType<DownloadStruct>();
-        qDBusRegisterMetaType<GroupDownloadStruct>();
-        qDBusRegisterMetaType<StructList>();
-        qDBusRegisterMetaType<HttpErrorStruct>();
-        qDBusRegisterMetaType<NetworkErrorStruct>();
-        qDBusRegisterMetaType<ProcessErrorStruct>();
-    }
-
-    void createDownload(DownloadStruct downStruct) {
-        Q_Q(Manager);
-        QDBusPendingCall call =
-            _dbusInterface->createDownload(downStruct);
-        DownloadCb cb = [](Download*) {};
-
-        auto watcher = new DownloadManagerPendingCallWatcher(_conn,
-                _servicePath, call, cb, cb,
-                static_cast<QObject*>(q));
-        q->connect(watcher, SIGNAL(callbackExecuted()),
-            q, SLOT(onWatcherDone()));
-    }
-
-    void createDownload(DownloadStruct downStruct,
-                        DownloadCb cb,
-                        DownloadCb errCb) {
-        Q_Q(Manager);
-        QDBusPendingCall call =
-            _dbusInterface->createDownload(downStruct);
-        auto watcher = new DownloadManagerPendingCallWatcher(_conn,
-                _servicePath, call, cb, errCb,
-                static_cast<QObject*>(q));
-        q->connect(watcher, SIGNAL(callbackExecuted()),
-            q, SLOT(onWatcherDone()));
-    }
-
-    void createDownload(StructList downs,
-                        const QString& algorithm,
-                        bool allowed3G,
-                        const QVariantMap& metadata,
-                        StringMap headers) {
-        Q_Q(Manager);
-        QDBusPendingCall call =
-            _dbusInterface->createDownloadGroup(downs,
-                algorithm, allowed3G, metadata, headers);
-
-        GroupCb cb = [](GroupDownload*) {};
-
-        auto watcher = new GroupManagerPendingCallWatcher(_conn, _servicePath,
-                call, cb, cb, static_cast<QObject*>(q));
-        q->connect(watcher, SIGNAL(callbackExecuted()),
-            q, SLOT(onWatcherDone()));
-    }
-
-    void createDownload(StructList downs,
-                        const QString& algorithm,
-                        bool allowed3G,
-                        const QVariantMap& metadata,
-                        StringMap headers,
-                        GroupCb cb,
-                        GroupCb errCb) {
-        Q_Q(Manager);
-        QDBusPendingCall call =
-            _dbusInterface->createDownloadGroup(downs,
-                algorithm, allowed3G, metadata, headers);
-        auto watcher = new GroupManagerPendingCallWatcher(_conn, _servicePath,
-                call, cb, errCb, static_cast<QObject*>(q));
-        q->connect(watcher, SIGNAL(callbackExecuted()),
-            q, SLOT(onWatcherDone()));
-    }
-
-    bool isError() {
-        return _isError;
-    }
-
-    Error* lastError() {
-        return _lastError;
-    }
-
-    void setLastError(const QDBusError& err) {
-        // delete the last if error if present to keep mem to a minimum
-        if (_lastError != nullptr) {
-            delete _lastError;
-        }
-        _lastError = new DBusError(err);
-        _isError = true;
-    }
-
-    void allowMobileDataDownload(bool allowed) {
-        QDBusPendingReply<> reply =
-            _dbusInterface->allowGSMDownload(allowed);
-        // we block but because we expect it to be fast
-        reply.waitForFinished();
-        if (reply.isError()) {
-            auto err = reply.error();
-            qCritical() << "Error setting mobile data" << err;
-            setLastError(err);
-        }
-    }
-
-    bool isMobileDataDownload() {
-        QDBusPendingReply<bool> reply =
-            _dbusInterface->isGSMDownloadAllowed();
-        // we block but because we expect it to be fast
-        reply.waitForFinished();
-        if (reply.isError()) {
-            auto err = reply.error();
-            qCritical() << "Error getting if mobile data is enabled"
-                << err;
-            setLastError(err);
-            return false;
-        } else {
-            return reply.value();
-        }
-    }
-
-    qulonglong defaultThrottle() {
-        QDBusPendingReply<qulonglong> reply =
-            _dbusInterface->defaultThrottle();
-        // we block but because we expect it to be fast
-        reply.waitForFinished();
-        if (reply.isError()) {
-            auto err = reply.error();
-            qCritical() << "Error getting the default throttle" << err;
-            setLastError(err);
-            return 0;
-        } else {
-            return reply.value();
-        }
-    }
-
-    void setDefaultThrottle(qulonglong speed) {
-        QDBusPendingReply<> reply =
-            _dbusInterface->setDefaultThrottle(speed);
-        // we block but because we expect it to be fast
-        reply.waitForFinished();
-        if (reply.isError()) {
-            auto err = reply.error();
-            qCritical() << "Error setting default throttle" << err;
-            setLastError(err);
-        }
-    }
-
-    void exit() {
-        QDBusPendingReply<> reply =
-            _dbusInterface->exit();
-        // we block but because we expect it to be fast
-        reply.waitForFinished();
-        if (reply.isError()) {
-            auto err = reply.error();
-            qCritical() << "Error setting killing the daemon" << err;
-            setLastError(err);
-        }
-    }
-
-    void onWatcherDone() {
-        Q_Q(Manager);
-        auto senderObj = q->sender();
-        senderObj->deleteLater();
-    }
-
- private:
-    bool _isError = false;
-    QDBusConnection _conn;
-    QString _servicePath;
-    Error* _lastError = nullptr;
-    ManagerInterface* _dbusInterface = nullptr;
-    Manager* q_ptr;
-};
-
-/*
- * PUBLIC IMPLEMENTATION
- */
-
-Manager::Manager(const QDBusConnection& conn,
-                 const QString& path,
-                 QObject* parent)
-    : QObject(parent),
-      d_ptr(new ManagerPrivate(conn, path, this)){
-}
-
-Manager::Manager(const QDBusConnection& conn,
-                 const QString& path,
-                 ManagerInterface* interface,
-                 QObject* parent)
-    : QObject(parent),
-      d_ptr(new ManagerPrivate(conn, path, interface, this)) {
-}
-
-Manager::~Manager() {
-    delete d_ptr;
-}
-
-Manager*
-Manager::createSessionManager(const QString& path, QObject* parent) {
-    if (path.isEmpty()) {
-        return new Manager(QDBusConnection::sessionBus(), DOWNLOAD_SERVICE, parent);
-    } else {
-        return new Manager(QDBusConnection::sessionBus(), path, parent);
-    }
-}
-
-Manager*
-Manager::createSystemManager(const QString& path, QObject* parent) {
-    if (path.isEmpty()) {
-        return new Manager(QDBusConnection::systemBus(), DOWNLOAD_SERVICE, parent);
-    } else {
-        return new Manager(QDBusConnection::systemBus(), path, parent);
-    }
-}
-
-void
-Manager::createDownload(DownloadStruct downStruct) {
-    Q_D(Manager);
-    d->createDownload(downStruct);
-}
-
-void
-Manager::createDownload(DownloadStruct downStruct,
-                        DownloadCb cb,
-                        DownloadCb errCb) {
-    Q_D(Manager);
-    d->createDownload(downStruct, cb, errCb);
-}
-
-void
-Manager::createDownload(StructList downs,
-                        const QString &algorithm,
-                        bool allowed3G,
-                        const QVariantMap &metadata,
-                        StringMap headers) {
-    Q_D(Manager);
-    d->createDownload(downs, algorithm, allowed3G, metadata, headers);
-}
-
-void
-Manager::createDownload(StructList downs,
-                        const QString& algorithm,
-                        bool allowed3G,
-                        const QVariantMap& metadata,
-                        StringMap headers,
-                        GroupCb cb,
-                        GroupCb errCb) {
-    Q_D(Manager);
-    d->createDownload(downs, algorithm, allowed3G, metadata, headers, cb,
-        errCb);
-}
-
-bool
-Manager::isError() {
-    Q_D(Manager);
-    return d->isError();
-}
-
-Error*
-Manager::lastError() {
-    Q_D(Manager);
-    return d->lastError();
-}
-
-void
-Manager::allowMobileDataDownload(bool allowed) {
-    Q_D(Manager);
-    d->allowMobileDataDownload(allowed);
-}
-
-bool
-Manager::isMobileDataDownload() {
-    Q_D(Manager);
-    return d->isMobileDataDownload();
+    }
+    _lastError = new DBusError(err);
+    _isError = true;
+}
+
+void
+ManagerImpl::allowMobileDataDownload(bool allowed) {
+    QDBusPendingReply<> reply =
+        _dbusInterface->allowGSMDownload(allowed);
+    // we block but because we expect it to be fast
+    reply.waitForFinished();
+    if (reply.isError()) {
+        auto err = reply.error();
+        qCritical() << "Error setting mobile data" << err;
+        setLastError(err);
+    }
+}
+
+bool
+ManagerImpl::isMobileDataDownload() {
+    QDBusPendingReply<bool> reply =
+        _dbusInterface->isGSMDownloadAllowed();
+    // we block but because we expect it to be fast
+    reply.waitForFinished();
+    if (reply.isError()) {
+        auto err = reply.error();
+        qCritical() << "Error getting if mobile data is enabled"
+            << err;
+        setLastError(err);
+        return false;
+    } else {
+        return reply.value();
+    }
 }
 
 qulonglong
-Manager::defaultThrottle() {
-    Q_D(Manager);
-    return d->defaultThrottle();
-}
-
-void
-Manager::setDefaultThrottle(qulonglong speed) {
-    Q_D(Manager);
-    d->setDefaultThrottle(speed);
-}
-
-void
-Manager::exit() {
-    Q_D(Manager);
-    d->exit();
+ManagerImpl::defaultThrottle() {
+    QDBusPendingReply<qulonglong> reply =
+        _dbusInterface->defaultThrottle();
+    // we block but because we expect it to be fast
+    reply.waitForFinished();
+    if (reply.isError()) {
+        auto err = reply.error();
+        qCritical() << "Error getting the default throttle" << err;
+        setLastError(err);
+        return 0;
+    } else {
+        return reply.value();
+    }
+}
+
+void
+ManagerImpl::setDefaultThrottle(qulonglong speed) {
+    QDBusPendingReply<> reply =
+        _dbusInterface->setDefaultThrottle(speed);
+    // we block but because we expect it to be fast
+    reply.waitForFinished();
+    if (reply.isError()) {
+        auto err = reply.error();
+        qCritical() << "Error setting default throttle" << err;
+        setLastError(err);
+    }
+}
+
+void
+ManagerImpl::exit() {
+    QDBusPendingReply<> reply =
+        _dbusInterface->exit();
+    // we block but because we expect it to be fast
+    reply.waitForFinished();
+    if (reply.isError()) {
+        auto err = reply.error();
+        qCritical() << "Error setting killing the daemon" << err;
+        setLastError(err);
+    }
+}
+
+void
+ManagerImpl::onWatcherDone() {
+    auto senderObj = sender();
+    senderObj->deleteLater();
 }
 
 }  // DownloadManager
 
 }  // Ubuntu
-
-#include "moc_manager.cpp"

=== renamed file 'ubuntu-download-manager-client/ubuntu/download_manager/manager.h' => 'ubuntu-download-manager-client/ubuntu/download_manager/manager_impl.h'
--- ubuntu-download-manager-client/ubuntu/download_manager/manager.h	2014-02-07 10:06:24 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/manager_impl.h	2014-02-19 18:29:41 +0000
@@ -16,16 +16,18 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_H
-#define UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_H
+#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_IMPL_H
+#define UBUNTU_DOWNLOADMANAGER_CLIENT_MANAGER_IMPL_H
 
-#include <functional>
-#include <QList>
-#include <QObject>
-#include <ubuntu/download_manager/metatypes.h>
-#include <ubuntu/download_manager/common.h>
-#include <ubuntu/download_manager/download_struct.h>
-#include <ubuntu/download_manager/group_download_struct.h>
+#include <QDBusConnection>
+#include <QDBusObjectPath>
+#include <ubuntu/download_manager/system/dbus_connection.h>
+#include "download.h"
+#include "error.h"
+#include "group_download.h"
+#include "manager_interface.h"
+#include "manager_pendingcall_watcher.h"
+#include "manager.h"
 
 
 class QDBusConnection;
@@ -39,20 +41,16 @@
 class GroupDownload;
 class ManagerInterface;
 
-typedef std::function<void(Download*)> DownloadCb;
-typedef std::function<void(GroupDownload*)> GroupCb;
-
-class ManagerPrivate;
-class DOWNLOAD_MANAGER_EXPORT Manager : public QObject {
-    Q_DECLARE_PRIVATE(Manager)
+class ManagerImpl : public Manager {
     Q_OBJECT
 
     // allow watchers to emit the signals
+    friend class Manager;
     friend class DownloadManagerPendingCallWatcher;
     friend class GroupManagerPendingCallWatcher;
 
  public:
-    virtual ~Manager();
+    virtual ~ManagerImpl();
     virtual void createDownload(DownloadStruct downStruct);
     virtual void createDownload(DownloadStruct downStruct,
                                 DownloadCb cb,
@@ -70,37 +68,36 @@
                                 GroupCb cb,
                                 GroupCb errCb);
 
-    bool isError();
-    Error* lastError();
+    bool isError() const;
+    Error* lastError() const;
     void allowMobileDataDownload(bool allowed);
     bool isMobileDataDownload();
     qulonglong defaultThrottle();
     void setDefaultThrottle(qulonglong speed);
     void exit();
 
-    static Manager* createSessionManager(const QString& path = "", QObject* parent=0);
-    static Manager* createSystemManager(const QString& path = "", QObject* parent=0);
-
- signals:
-    void downloadCreated(Download* down);
-    void groupCreated(GroupDownload* down);
-
  protected:
-    Manager(const QDBusConnection& conn,
+    ManagerImpl(const QDBusConnection& conn,
             const QString& path = "",
             QObject* parent= 0);
     // used for testing purposes
-    Manager(const QDBusConnection& conn,
+    ManagerImpl(const QDBusConnection& conn,
             const QString& path,
             ManagerInterface* interface,
             QObject* parent);
 
  private:
-    Q_PRIVATE_SLOT(d_func(), void onWatcherDone())
+    void init();
+    void onWatcherDone();
+    void setLastError(const QDBusError& err);
 
  private:
-    // use pimpl pattern so that users do not have to be recompiled
-    ManagerPrivate* d_ptr;
+    bool _isError = false;
+    QDBusConnection _conn;
+    QString _servicePath;
+    Error* _lastError = nullptr;
+    ManagerInterface* _dbusInterface = nullptr;
+
 };
 
 }  // DownloadManager

=== modified file 'ubuntu-download-manager-client/ubuntu/download_manager/manager_pendingcall_watcher.cpp'
--- ubuntu-download-manager-client/ubuntu/download_manager/manager_pendingcall_watcher.cpp	2014-02-03 17:48:28 +0000
+++ ubuntu-download-manager-client/ubuntu/download_manager/manager_pendingcall_watcher.cpp	2014-02-19 18:29:41 +0000
@@ -19,7 +19,7 @@
 #include <QDebug>
 #include <QDBusPendingReply>
 #include <QDBusObjectPath>
-#include "download.h"
+#include "download_impl.h"
 #include "error.h"
 #include "group_download.h"
 #include "manager.h"
@@ -51,13 +51,13 @@
         qDebug() << "ERROR" << reply.error() << reply.error().type();
         // creater error and deal with it
         auto err = new DBusError(reply.error());
-        auto down = new Download(_conn, err);
+        auto down = new DownloadImpl(_conn, err);
         _errCb(down);
         emit man->downloadCreated(down);
     } else {
         qDebug() << "Success!";
         auto path = reply.value();
-        auto down = new Download(_conn, _servicePath, path);
+        auto down = new DownloadImpl(_conn, _servicePath, path);
         emit man->downloadCreated(down);
         _cb(down);
     }

=== modified file 'ubuntu-download-manager-common/ubuntu-download-manager-common.pro'
--- ubuntu-download-manager-common/ubuntu-download-manager-common.pro	2014-02-07 10:06:24 +0000
+++ ubuntu-download-manager-common/ubuntu-download-manager-common.pro	2014-02-19 18:29:41 +0000
@@ -16,7 +16,8 @@
     ubuntu/download_manager/system/hash_algorithm.cpp \
     ubuntu/download_manager/http_error_struct.cpp \
     ubuntu/download_manager/network_error_struct.cpp \
-    ubuntu/download_manager/process_error_struct.cpp
+    ubuntu/download_manager/process_error_struct.cpp \
+    ubuntu/download_manager/auth_error_struct.cpp
 
 public_headers = \
     ubuntu/download_manager/common.h \
@@ -25,7 +26,8 @@
     ubuntu/download_manager/group_download_struct.h \
     ubuntu/download_manager/http_error_struct.h \
     ubuntu/download_manager/network_error_struct.h \
-    ubuntu/download_manager/process_error_struct.h
+    ubuntu/download_manager/process_error_struct.h \
+    ubuntu/download_manager/auth_error_struct.h
 
 private_headers = \
     ubuntu/download_manager/system/dbus_connection.h \

=== added file 'ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.cpp'
--- ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.cpp	2014-02-19 18:29:41 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDBusArgument>
+#include "auth_error_struct.h"
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+AuthErrorStruct::AuthErrorStruct()
+    : _type(),
+      _phrase("") {
+}
+
+AuthErrorStruct::AuthErrorStruct(AuthErrorStruct::Type type, QString phrase)
+    : _type(type),
+      _phrase(phrase) {
+}
+
+AuthErrorStruct::AuthErrorStruct(int type, QString phrase)
+    : _type(static_cast<AuthErrorStruct::Type>(type)),
+      _phrase(phrase) {
+}
+
+AuthErrorStruct::AuthErrorStruct(const AuthErrorStruct& other)
+    : _type(other._type),
+      _phrase(other._phrase){
+}
+
+AuthErrorStruct&
+AuthErrorStruct::operator=(const AuthErrorStruct& other) {
+    _type = other._type;
+    _phrase = other._phrase;
+
+    return *this;
+}
+
+QDBusArgument&
+operator<<(QDBusArgument &argument,
+           const AuthErrorStruct& error) {
+    argument.beginStructure();
+    argument << static_cast<int>(error._type);
+    argument << error._phrase;
+    argument.endStructure();
+
+    return argument;
+}
+
+const QDBusArgument&
+operator>>(const QDBusArgument &argument,
+           AuthErrorStruct& error) {
+    int tempType;
+    argument.beginStructure();
+    argument >> tempType;
+    argument >> error._phrase;
+    argument.endStructure();
+
+    error._type = static_cast<AuthErrorStruct::Type>(tempType);
+
+    return argument;
+}
+
+
+AuthErrorStruct::Type
+AuthErrorStruct::getType() {
+    return _type;
+}
+
+QString
+AuthErrorStruct::getPhrase() {
+    return _phrase;
+}
+
+}  // DownloadManager
+
+}  // Ubuntu

=== added file 'ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.h'
--- ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-common/ubuntu/download_manager/auth_error_struct.h	2014-02-19 18:29:41 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef DOWNLOADER_LIB_AUTH_ERROR_STRUCT_H
+#define DOWNLOADER_LIB_AUTH_ERROR_STRUCT_H
+
+#include "common.h"
+
+class QDBusArgument;
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+class AuthErrorStruct {
+    Q_PROPERTY(AuthErrorStruct::Type type READ getType)
+    Q_PROPERTY(QString phrase READ getPhrase)
+ public:
+    enum Type {
+        Server,
+        Proxy
+    };
+
+    AuthErrorStruct();
+    AuthErrorStruct(AuthErrorStruct::Type type, QString phrase);
+    AuthErrorStruct(int type, QString phrase);
+    AuthErrorStruct(const AuthErrorStruct& other);
+    AuthErrorStruct& operator=(const AuthErrorStruct& other);
+
+    friend QDBusArgument &operator<<(QDBusArgument &argument,
+        const AuthErrorStruct& error);
+    friend const QDBusArgument &operator>>(const QDBusArgument &argument,
+        AuthErrorStruct& error);
+
+    // properties getters
+    AuthErrorStruct::Type getType();
+    QString getPhrase();
+
+ private:
+    AuthErrorStruct::Type _type;
+    QString _phrase;
+};
+
+}  // DownloadManager
+
+}  // Ubuntu
+#endif // AUTH_ERROR_STRUCT_H

=== modified file 'ubuntu-download-manager-common/ubuntu/download_manager/metatypes.h'
--- ubuntu-download-manager-common/ubuntu/download_manager/metatypes.h	2014-01-31 15:13:08 +0000
+++ ubuntu-download-manager-common/ubuntu/download_manager/metatypes.h	2014-02-19 18:29:41 +0000
@@ -21,6 +21,7 @@
 
 #include <QMap>
 #include <QList>
+#include "auth_error_struct.h"
 #include "http_error_struct.h"
 #include "network_error_struct.h"
 #include "process_error_struct.h"
@@ -32,7 +33,7 @@
 typedef QMap<QString, QString> StringMap;
 typedef QList<GroupDownloadStruct> StructList;
 
-
+Q_DECLARE_METATYPE(AuthErrorStruct)
 Q_DECLARE_METATYPE(HttpErrorStruct)
 Q_DECLARE_METATYPE(NetworkErrorStruct)
 Q_DECLARE_METATYPE(ProcessErrorStruct)

=== modified file 'ubuntu-download-manager-priv/downloads/download_adaptor.h'
--- ubuntu-download-manager-priv/downloads/download_adaptor.h	2014-01-27 16:36:44 +0000
+++ ubuntu-download-manager-priv/downloads/download_adaptor.h	2014-02-19 18:29:41 +0000
@@ -9,8 +9,8 @@
  * before re-generating it.
  */
 
-#ifndef DOWNLOAD_ADAPTOR_H_1390825398
-#define DOWNLOAD_ADAPTOR_H_1390825398
+#ifndef DOWNLOAD_ADAPTOR_H_1392117488
+#define DOWNLOAD_ADAPTOR_H_1392117488
 
 #include <QtCore/QObject>
 #include <QtDBus/QtDBus>
@@ -78,6 +78,10 @@
 "    <signal name=\"error\">\n"
 "      <arg direction=\"out\" type=\"s\" name=\"error\"/>\n"
 "    </signal>\n"
+"    <signal name=\"authError\">\n"
+"      <annotation value=\"AuthErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In0\"/>\n"
+"      <arg direction=\"out\" type=\"(is)\" name=\"error\"/>\n"
+"    </signal>\n"
 "    <signal name=\"httpError\">\n"
 "      <annotation value=\"HttpErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In0\"/>\n"
 "      <arg direction=\"out\" type=\"(is)\" name=\"error\"/>\n"
@@ -117,6 +121,7 @@
     qulonglong throttle();
     qulonglong totalSize();
 Q_SIGNALS: // SIGNALS
+    void authError(AuthErrorStruct error);
     void canceled(bool success);
     void error(const QString &error);
     void finished(const QString &path);

=== modified file 'ubuntu-download-manager-priv/downloads/file_download.cpp'
--- ubuntu-download-manager-priv/downloads/file_download.cpp	2014-02-04 16:23:10 +0000
+++ ubuntu-download-manager-priv/downloads/file_download.cpp	2014-02-19 18:29:41 +0000
@@ -40,6 +40,9 @@
     const QString COMMAND_ERROR = "COMMAND ERROR";
     const QString SSL_ERROR = "SSL ERROR";
     const QString FILE_SYSTEM_ERROR = "FILE SYSTEM ERROR: %1";
+    const QString AUTH_ERROR = "AUTHENTICATION ERROR";
+    const QString PROXY_AUTH_ERROR = "PROXY_AUTHENTICATION ERROR";
+    const QString UNEXPECTED_ERROR = "UNEXPECTED_ERROR";
 
 }
 
@@ -81,7 +84,7 @@
       _hash(hash) {
     init();
     _algo = HashAlgorithm::getHashAlgo(algo);
-    // check that the algorithm is correct if the hash is not emtpy
+    // check that the algorithm is correct if the hash is not empty
     if (!_hash.isEmpty() && !HashAlgorithm::isValidAlgo(algo)) {
         setIsValid(false);
         setLastError(QString("Invalid hash algorithm: '%1'").arg(algo));
@@ -190,7 +193,7 @@
         return;
     }
 
-    // create file that will be used to mantain the state of the
+    // create file that will be used to maintain the state of the
     // download when resumed.
     _currentData = FileManager::instance()->createFile(_filePath);
     bool canWrite = _currentData->open(QIODevice::ReadWrite | QFile::Append);
@@ -265,6 +268,7 @@
     LOG(ERROR) << _url << " ERROR:" << ":" << code;
     _downloading = false;
     QString msg;
+    QString errStr;
 
     // decide if we are talking about an http error or no
     auto statusCode = _reply->attribute(
@@ -281,13 +285,23 @@
             }
             HttpErrorStruct err(status, msg);
             emit httpError(err);
+            errStr = NETWORK_ERROR;
         }
     } else {
-        NetworkErrorStruct err(code);
-        emit networkError(err);
+        if (code == QNetworkReply::AuthenticationRequiredError) {
+            AuthErrorStruct err(AuthErrorStruct::Server, _reply->errorString());
+            emit authError(err);
+            errStr = AUTH_ERROR;
+        } else if (code == QNetworkReply::ProxyAuthenticationRequiredError) {
+            AuthErrorStruct err(AuthErrorStruct::Proxy, _reply->errorString());
+            emit authError(err);
+            errStr = PROXY_AUTH_ERROR;
+        } else {
+            NetworkErrorStruct err(code, _reply->errorString());
+            emit networkError(err);
+        }
     }
-
-    emitError(NETWORK_ERROR);
+    emitError(errStr);
 }
 
 void
@@ -351,7 +365,7 @@
     // there are two possible cases, the first, we do not have the metadata
     // info to execute a command once the download was finished and that
     // means we are done here else we execute the command AND raise the
-    // finish signals once the command was done (or an error ocurred in
+    // finish signals once the command was done (or an error occurred in
     // the command execution.
     if (metadata().contains(METADATA_COMMAND_KEY)) {
         // just emit processing if we DO NOT have a hash because else we
@@ -367,7 +381,7 @@
             emitError(COMMAND_ERROR);
             return;
         } else {
-            // first item of the string list is the commnad
+            // first item of the string list is the command
             // the rest is the arguments
             QString command = commandData.at(0);
             commandData.removeAt(0);

=== modified file 'ubuntu-download-manager-priv/downloads/file_download.h'
--- ubuntu-download-manager-priv/downloads/file_download.h	2014-02-07 10:06:24 +0000
+++ ubuntu-download-manager-priv/downloads/file_download.h	2014-02-19 18:29:41 +0000
@@ -24,6 +24,7 @@
 #include <QProcess>
 #include <QSharedPointer>
 #include <QUrl>
+#include <ubuntu/download_manager/auth_error_struct.h>
 #include <ubuntu/download_manager/http_error_struct.h>
 #include <ubuntu/download_manager/network_error_struct.h>
 #include <ubuntu/download_manager/process_error_struct.h>
@@ -92,6 +93,7 @@
 
  signals:
     void finished(const QString& path);
+    void authError(AuthErrorStruct error);
     void httpError(HttpErrorStruct error);
     void networkError(NetworkErrorStruct error);
     void processError(ProcessErrorStruct error);

=== modified file 'ubuntu-download-manager-priv/downloads/group_download.cpp'
--- ubuntu-download-manager-priv/downloads/group_download.cpp	2014-01-28 16:03:24 +0000
+++ ubuntu-download-manager-priv/downloads/group_download.cpp	2014-02-19 18:29:41 +0000
@@ -55,8 +55,6 @@
 
 void
 GroupDownload::connectToDownloadSignals(FileDownload* singleDownload) {
-    connect(singleDownload, &Download::error,
-        this, &GroupDownload::onError);
     connect(singleDownload, static_cast<void(Download::*)
             (qulonglong, qulonglong)>(&Download::progress),
                 this, &GroupDownload::onProgress);
@@ -64,6 +62,18 @@
         this, &GroupDownload::onFinished);
     connect(singleDownload, &FileDownload::processing,
         this, &GroupDownload::processing);
+
+    // connect to the error signals
+    connect(singleDownload, &Download::error,
+        this, &GroupDownload::onError);
+    connect(singleDownload, &FileDownload::authError,
+        this, &GroupDownload::onAuthError);
+    connect(singleDownload, &FileDownload::httpError,
+        this, &GroupDownload::onHttpError);
+    connect(singleDownload, &FileDownload::networkError,
+        this, &GroupDownload::onNetworkError);
+    connect(singleDownload, &FileDownload::processError,
+        this, &GroupDownload::onProcessError);
 }
 
 void
@@ -246,6 +256,48 @@
     emitError(errorMsg);
 }
 
+QString
+GroupDownload::getUrlFromSender(QObject* sender) {
+    auto down = qobject_cast<FileDownload*>(sender);
+    if (down != nullptr) {
+        return down->url().toString();
+    } else {
+        return "";
+    }
+}
+
+void
+GroupDownload::onAuthError(AuthErrorStruct err) {
+    auto url = getUrlFromSender(sender());
+    if (!url.isEmpty()) {
+        emit authError(url, err);
+    }
+}
+
+void
+GroupDownload::onHttpError(HttpErrorStruct err) {
+    auto url = getUrlFromSender(sender());
+    if (!url.isEmpty()) {
+        emit httpError(url, err);
+    }
+}
+
+void
+GroupDownload::onNetworkError(NetworkErrorStruct err) {
+    auto url = getUrlFromSender(sender());
+    if (!url.isEmpty()) {
+        emit networkError(url, err);
+    }
+}
+
+void
+GroupDownload::onProcessError(ProcessErrorStruct err) {
+    auto url = getUrlFromSender(sender());
+    if (!url.isEmpty()) {
+        emit processError(url, err);
+    }
+}
+
 void
 GroupDownload::onProgress(qulonglong received, qulonglong total) {
     FileDownload* down = qobject_cast<FileDownload*>(sender());

=== modified file 'ubuntu-download-manager-priv/downloads/group_download.h'
--- ubuntu-download-manager-priv/downloads/group_download.h	2014-02-01 09:01:47 +0000
+++ ubuntu-download-manager-priv/downloads/group_download.h	2014-02-19 18:29:41 +0000
@@ -65,6 +65,10 @@
 
  signals:
     void finished(const QStringList &path);
+    void authError(const QString &url, AuthErrorStruct error);
+    void httpError(const QString &url, HttpErrorStruct error);
+    void networkError(const QString &url, NetworkErrorStruct error);
+    void processError(const QString &url, ProcessErrorStruct error);
 
  private:
     void cancelAllDownloads();
@@ -72,12 +76,19 @@
     void init(QList<GroupDownloadStruct> downloads,
               const QString& algo,
               bool isGSMDownloadAllowed);
-    void onError(const QString& error);
+    QString getUrlFromSender(QObject* sender);
     void onProgress(qulonglong received, qulonglong total);
     void onFinished(const QString& file);
+    void onError(const QString& error);
+    void onAuthError(AuthErrorStruct err);
+    void onHttpError(HttpErrorStruct err);
+    void onNetworkError(NetworkErrorStruct err);
+    void onProcessError(ProcessErrorStruct err);
 
- private:
+ protected:
     QList<FileDownload*> _downloads;
+
+ private:
     QStringList _finishedDownloads;
     QMap<QUrl, QPair<qulonglong, qulonglong> > _downloadsProgress;
     Factory* _downFactory = nullptr;

=== modified file 'ubuntu-download-manager-priv/downloads/group_download_adaptor.cpp'
--- ubuntu-download-manager-priv/downloads/group_download_adaptor.cpp	2013-12-11 13:55:36 +0000
+++ ubuntu-download-manager-priv/downloads/group_download_adaptor.cpp	2014-02-19 18:29:41 +0000
@@ -42,19 +42,19 @@
 
 void GroupDownloadAdaptor::allowGSMDownload(bool allowed)
 {
-    // handle method call com.canonical.applications.Download.allowGSMDownload
+    // handle method call com.canonical.applications.GroupDownload.allowGSMDownload
     QMetaObject::invokeMethod(parent(), "allowGSMDownload", Q_ARG(bool, allowed));
 }
 
 void GroupDownloadAdaptor::cancel()
 {
-    // handle method call com.canonical.applications.Download.cancel
+    // handle method call com.canonical.applications.GroupDownload.cancel
     QMetaObject::invokeMethod(parent(), "cancel");
 }
 
 bool GroupDownloadAdaptor::isGSMDownloadAllowed()
 {
-    // handle method call com.canonical.applications.Download.isGSMDownloadAllowed
+    // handle method call com.canonical.applications.GroupDownload.isGSMDownloadAllowed
     bool allowed;
     QMetaObject::invokeMethod(parent(), "isGSMDownloadAllowed", Q_RETURN_ARG(bool, allowed));
     return allowed;
@@ -62,7 +62,7 @@
 
 QVariantMap GroupDownloadAdaptor::metadata()
 {
-    // handle method call com.canonical.applications.Download.metadata
+    // handle method call com.canonical.applications.GroupDownload.metadata
     QVariantMap data;
     QMetaObject::invokeMethod(parent(), "metadata", Q_RETURN_ARG(QVariantMap, data));
     return data;
@@ -70,37 +70,37 @@
 
 void GroupDownloadAdaptor::pause()
 {
-    // handle method call com.canonical.applications.Download.pause
+    // handle method call com.canonical.applications.GroupDownload.pause
     QMetaObject::invokeMethod(parent(), "pause");
 }
 
 qulonglong GroupDownloadAdaptor::progress(qulonglong &started, qulonglong &paused, qulonglong &finished)
 {
-    // handle method call com.canonical.applications.Download.progress
+    // handle method call com.canonical.applications.GroupDownload.progress
     return static_cast<GroupDownload*>(parent())->progress(started, paused, finished);
 }
 
 void GroupDownloadAdaptor::resume()
 {
-    // handle method call com.canonical.applications.Download.resume
+    // handle method call com.canonical.applications.GroupDownload.resume
     QMetaObject::invokeMethod(parent(), "resume");
 }
 
 void GroupDownloadAdaptor::setThrottle(qulonglong speed)
 {
-    // handle method call com.canonical.applications.Download.setThrottle
+    // handle method call com.canonical.applications.GroupDownload.setThrottle
     QMetaObject::invokeMethod(parent(), "setThrottle", Q_ARG(qulonglong, speed));
 }
 
 void GroupDownloadAdaptor::start()
 {
-    // handle method call com.canonical.applications.Download.start
+    // handle method call com.canonical.applications.GroupDownload.start
     QMetaObject::invokeMethod(parent(), "start");
 }
 
 qulonglong GroupDownloadAdaptor::throttle()
 {
-    // handle method call com.canonical.applications.Download.throttle
+    // handle method call com.canonical.applications.GroupDownload.throttle
     qulonglong speed;
     QMetaObject::invokeMethod(parent(), "throttle", Q_RETURN_ARG(qulonglong, speed));
     return speed;
@@ -108,7 +108,7 @@
 
 qulonglong GroupDownloadAdaptor::totalSize()
 {
-    // handle method call com.canonical.applications.Download.totalSize
+    // handle method call com.canonical.applications.GroupDownload.totalSize
     qulonglong total;
     QMetaObject::invokeMethod(parent(), "totalSize", Q_RETURN_ARG(qulonglong, total));
     return total;

=== modified file 'ubuntu-download-manager-priv/downloads/group_download_adaptor.h'
--- ubuntu-download-manager-priv/downloads/group_download_adaptor.h	2013-12-11 13:55:36 +0000
+++ ubuntu-download-manager-priv/downloads/group_download_adaptor.h	2014-02-19 18:29:41 +0000
@@ -9,8 +9,8 @@
  * before re-generating it.
  */
 
-#ifndef GROUP_DOWNLOAD_ADAPTOR_H_1377511556
-#define GROUP_DOWNLOAD_ADAPTOR_H_1377511556
+#ifndef GROUP_DOWNLOAD_ADAPTOR_H_1392149243
+#define GROUP_DOWNLOAD_ADAPTOR_H_1392149243
 
 #include <QtCore/QObject>
 #include <QtDBus/QtDBus>
@@ -31,7 +31,7 @@
 namespace Daemon {
 
 /*
- * Adaptor class for interface com.canonical.applications.Download
+ * Adaptor class for interface com.canonical.applications.GroupDownload
  */
 class GroupDownloadAdaptor: public QDBusAbstractAdaptor
 {
@@ -86,6 +86,26 @@
 "    <signal name=\"error\">\n"
 "      <arg direction=\"out\" type=\"s\" name=\"error\"/>\n"
 "    </signal>\n"
+"    <signal name=\"authError\">\n"
+"      <annotation value=\"AuthErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In1\"/>\n"
+"      <arg direction=\"out\" type=\"s\" name=\"url\"/>\n"
+"      <arg direction=\"out\" type=\"(is)\" name=\"error\"/>\n"
+"    </signal>\n"
+"    <signal name=\"httpError\">\n"
+"      <annotation value=\"HttpErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In1\"/>\n"
+"      <arg direction=\"out\" type=\"s\" name=\"url\"/>\n"
+"      <arg direction=\"out\" type=\"(is)\" name=\"error\"/>\n"
+"    </signal>\n"
+"    <signal name=\"networkError\">\n"
+"      <annotation value=\"NetworkErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In1\"/>\n"
+"      <arg direction=\"out\" type=\"s\" name=\"url\"/>\n"
+"      <arg direction=\"out\" type=\"(is)\" name=\"error\"/>\n"
+"    </signal>\n"
+"    <signal name=\"processError\">\n"
+"      <annotation value=\"ProcessErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In1\"/>\n"
+"      <arg direction=\"out\" type=\"s\" name=\"url\"/>\n"
+"      <arg direction=\"out\" type=\"(isiss)\" name=\"error\"/>\n"
+"    </signal>\n"
 "    <signal name=\"progress\">\n"
 "      <arg direction=\"out\" type=\"t\" name=\"received\"/>\n"
 "      <arg direction=\"out\" type=\"t\" name=\"total\"/>\n"
@@ -113,10 +133,14 @@
     qulonglong throttle();
     qulonglong totalSize();
 Q_SIGNALS: // SIGNALS
+    void authError(const QString &url, AuthErrorStruct error);
     void canceled(bool success);
     void error(const QString &error);
     void finished(const QStringList &path);
+    void httpError(const QString &url, HttpErrorStruct error);
+    void networkError(const QString &url, NetworkErrorStruct error);
     void paused(bool success);
+    void processError(const QString &url, ProcessErrorStruct error);
     void processing(const QString &path);
     void progress(qulonglong received, qulonglong total);
     void resumed(bool success);

=== modified file 'ubuntu-download-manager-priv/downloads/manager.cpp'
--- ubuntu-download-manager-priv/downloads/manager.cpp	2014-02-10 09:51:58 +0000
+++ ubuntu-download-manager-priv/downloads/manager.cpp	2014-02-19 18:29:41 +0000
@@ -76,6 +76,7 @@
     qDBusRegisterMetaType<DownloadStruct>();
     qDBusRegisterMetaType<GroupDownloadStruct>();
     qDBusRegisterMetaType<StructList>();
+    qDBusRegisterMetaType<AuthErrorStruct>();
     qDBusRegisterMetaType<HttpErrorStruct>();
     qDBusRegisterMetaType<NetworkErrorStruct>();
     qDBusRegisterMetaType<ProcessErrorStruct>();

=== modified file 'ubuntu-download-manager-priv/system/network_reply.cpp'
--- ubuntu-download-manager-priv/system/network_reply.cpp	2014-02-03 13:34:10 +0000
+++ ubuntu-download-manager-priv/system/network_reply.cpp	2014-02-19 18:29:41 +0000
@@ -28,7 +28,7 @@
 NetworkReply::NetworkReply(QNetworkReply* reply, QObject* parent)
     : QObject(parent),
       _reply(reply) {
-    // connect to all the signals so that we foward them
+    // connect to all the signals so that we forward them
     if (_reply != nullptr) {
         connect(_reply, &QNetworkReply::downloadProgress,
             this, &NetworkReply::downloadProgress);
@@ -36,7 +36,7 @@
             this, &NetworkReply::finished);
         connect(_reply, &QNetworkReply::sslErrors,
             this, &NetworkReply::sslErrors);
-	// becuase error is overloaded we need to help the compiler
+	// because error is overloaded we need to help the compiler
 	connect(_reply, static_cast<void(QNetworkReply::*)
 	    (QNetworkReply::NetworkError)>(&QNetworkReply::error),
 		this, &NetworkReply::error);
@@ -106,6 +106,11 @@
     return _reply->attribute(code);
 }
 
+QString
+NetworkReply::errorString() const {
+    return _reply->errorString();
+}
+
 }  // System
 
 }  // DownloadManager

=== modified file 'ubuntu-download-manager-priv/system/network_reply.h'
--- ubuntu-download-manager-priv/system/network_reply.h	2014-01-27 16:36:44 +0000
+++ ubuntu-download-manager-priv/system/network_reply.h	2014-02-19 18:29:41 +0000
@@ -44,9 +44,10 @@
     virtual void setAcceptedCertificates(const QList<QSslCertificate>& certs);
     virtual bool canIgnoreSslErrors(const QList<QSslError>& errors);
     virtual QVariant attribute(QNetworkRequest::Attribute code) const;
+    virtual QString errorString() const;
 
  signals:
-    // signals fowarded from the real reply object
+    // signals forwarded from the real reply object
     void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
     void error(QNetworkReply::NetworkError code);
     void finished();

=== modified file 'ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro'
--- ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro	2014-02-03 17:50:07 +0000
+++ ubuntu-download-manager-test-lib/ubuntu-download-manager-test-lib.pro	2014-02-19 18:29:41 +0000
@@ -34,7 +34,8 @@
            ubuntu/download_manager/tests/client/testing_manager_adaptor.cpp \
            ubuntu/download_manager/tests/client/testing_interface.cpp \
            ubuntu/download_manager/tests/client/testing_file_download.cpp \
-           ubuntu/download_manager/tests/server/apn_request_factory.cpp
+           ubuntu/download_manager/tests/server/apn_request_factory.cpp \
+    ubuntu/download_manager/tests/server/group_download.cpp
 
 HEADERS += ubuntu/download_manager/tests/base_testcase.h \
            ubuntu/download_manager/tests/fake.h\
@@ -62,7 +63,8 @@
            ubuntu/download_manager/tests/client/testing_manager_adaptor.h \
            ubuntu/download_manager/tests/client/testing_interface.h \
            ubuntu/download_manager/tests/client/testing_file_download.h \
-           ubuntu/download_manager/tests/server/apn_request_factory.h
+           ubuntu/download_manager/tests/server/apn_request_factory.h \
+    ubuntu/download_manager/tests/server/group_download.h
 
 LIBS += -L$$OUT_PWD/../ubuntu-download-manager-common/ -lubuntu-download-manager-common
 

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.cpp	2014-02-04 16:08:36 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.cpp	2014-02-19 18:29:41 +0000
@@ -89,6 +89,27 @@
 }
 
 void
+DaemonTestCase::returnAuthError(const QString &download, AuthErrorStruct error) {
+    if (_daemonProcess != nullptr) {
+        auto conn = QDBusConnection::sessionBus();
+        QScopedPointer<TestingInterface> testingInterface(new TestingInterface(
+            _daemonPath, "/", conn));
+        QDBusPendingReply<> reply =
+            testingInterface->returnAuthError(download, error);
+        reply.waitForFinished();
+
+        if (reply.isError()) {
+	    auto error = reply.error();
+	    QString msg = "Could not tell the daemon to return Auth errors: "
+                + error.name() + ":" +  error.message();
+            QFAIL(msg.toUtf8());
+        }
+    } else {
+        QFAIL("returnHttpError must be used after init has been executed.");
+    }
+}
+
+void
 DaemonTestCase::returnHttpError(const QString &download, HttpErrorStruct error) {
     if (_daemonProcess != nullptr) {
         auto conn = QDBusConnection::sessionBus();

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.h	2014-02-04 16:08:36 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/daemon_testcase.h	2014-02-19 18:29:41 +0000
@@ -43,6 +43,7 @@
     QUrl serverUrl();
     void addFileToHttpServer(const QString& absolutePath);
     void returnDBusErrors(bool errors);
+    void returnAuthError(const QString &download, AuthErrorStruct error);
     void returnHttpError(const QString &download, HttpErrorStruct error);
     void returnNetworkError(const QString &download, NetworkErrorStruct error);
     void returnProcessError(const QString &download, ProcessErrorStruct error);

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.cpp	2014-02-03 17:48:28 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.cpp	2014-02-19 18:29:41 +0000
@@ -40,6 +40,13 @@
 }
 
 void
+TestingDaemon::returnAuthError(const QString &download,
+                               AuthErrorStruct error) {
+    auto man = qobject_cast<TestingManager*>(manager());
+    man->returnAuthError(download, error);
+}
+
+void
 TestingDaemon::returnHttpError(const QString &download,
                                HttpErrorStruct error) {
     auto man = qobject_cast<TestingManager*>(manager());

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.h	2014-02-03 17:52:16 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_daemon.h	2014-02-19 18:29:41 +0000
@@ -32,6 +32,7 @@
 
     // let the client test to tell the manager to return dbus errors
     void returnDBusErrors(bool errors);
+    void returnAuthError(const QString &download, AuthErrorStruct error);
     void returnHttpError(const QString &download, HttpErrorStruct error);
     void returnNetworkError(const QString &download, NetworkErrorStruct error);
     void returnProcessError(const QString &download, ProcessErrorStruct error);

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.cpp	2014-02-04 16:08:36 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.cpp	2014-02-19 18:29:41 +0000
@@ -62,6 +62,7 @@
 
 void
 TestingFileDownload::returnHttpError(HttpErrorStruct error) {
+    _returnAuthError = false;
     _returnHttpError = true;
     _returnNetworkError = false;
      _returnProcessError = false;
@@ -70,6 +71,7 @@
 
 void
 TestingFileDownload::returnNetworkError(NetworkErrorStruct error) {
+    _returnAuthError = false;
     _returnHttpError = false;
     _returnNetworkError = true;
      _returnProcessError = false;
@@ -78,10 +80,20 @@
 
 void
 TestingFileDownload::returnProcessError(ProcessErrorStruct error) {
-    _returnHttpError = false;
-    _returnNetworkError = false;
-     _returnProcessError = true;
-     _processErr = error;
+    _returnAuthError = false;
+    _returnHttpError = false;
+    _returnNetworkError = false;
+    _returnProcessError = true;
+    _processErr = error;
+}
+
+void
+TestingFileDownload::returnAuthError(AuthErrorStruct error) {
+    _returnAuthError = true;
+    _returnHttpError = false;
+    _returnNetworkError = false;
+    _returnProcessError = false;
+    _authErr = error;
 }
 
 qulonglong
@@ -186,6 +198,11 @@
 
     _down->start();
 
+    if (_returnAuthError) {
+        emit authError(_authErr);
+        emitError("Forced http error");
+    }
+
     if (_returnHttpError) {
         emit httpError(_httpErr);
         emitError("Forced http error");

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.h	2014-02-04 16:08:36 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_file_download.h	2014-02-19 18:29:41 +0000
@@ -37,6 +37,7 @@
     void returnHttpError(HttpErrorStruct error);
     void returnNetworkError(NetworkErrorStruct error);
     void returnProcessError(ProcessErrorStruct error);
+    void returnAuthError(AuthErrorStruct error);
 
  public slots:  // NOLINT(whitespace/indent)
     qulonglong progress() override;
@@ -64,9 +65,11 @@
 
  private:
     bool _returnErrors = false;
+    bool _returnAuthError = false;
     bool _returnHttpError = false;
     bool _returnNetworkError = false;
     bool _returnProcessError = false;
+    AuthErrorStruct _authErr;
     HttpErrorStruct _httpErr;
     NetworkErrorStruct _networkErr;
     ProcessErrorStruct _processErr;

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_interface.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_interface.h	2014-02-03 17:48:28 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_interface.h	2014-02-19 18:29:41 +0000
@@ -8,8 +8,8 @@
  * Do not edit! All changes made to it will be lost.
  */
 
-#ifndef TESTING_INTERFACE_H_1391440734
-#define TESTING_INTERFACE_H_1391440734
+#ifndef TESTING_INTERFACE_H_1392137146
+#define TESTING_INTERFACE_H_1392137146
 
 #include <QtCore/QObject>
 #include <QtCore/QByteArray>
@@ -37,6 +37,13 @@
     ~TestingInterface();
 
 public Q_SLOTS: // METHODS
+    inline QDBusPendingReply<> returnAuthError(const QString &download, AuthErrorStruct error)
+    {
+        QList<QVariant> argumentList;
+        argumentList << QVariant::fromValue(download) << QVariant::fromValue(error);
+        return asyncCallWithArgumentList(QLatin1String("returnAuthError"), argumentList);
+    }
+
     inline QDBusPendingReply<> returnDBusErrors(bool returnErrors)
     {
         QList<QVariant> argumentList;

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.cpp	2014-02-04 16:08:36 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.cpp	2014-02-19 18:29:41 +0000
@@ -74,6 +74,18 @@
     }
 }
 
+void
+TestingManager::returnAuthError(const QString &download,
+                                AuthErrorStruct error) {
+    auto q = queue();
+    foreach(Download* down, q->downloads().values()) {
+        auto testDown = qobject_cast<TestingFileDownload*>(down);
+        if (testDown != nullptr && testDown->url() == download) {
+            testDown->returnAuthError(error);
+        }
+    }
+}
+
 QDBusObjectPath
 TestingManager::registerDownload(Download* download) {
     QDBusObjectPath path;

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.h	2014-02-03 17:48:28 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager.h	2014-02-19 18:29:41 +0000
@@ -58,6 +58,7 @@
     void returnHttpError(const QString &download, HttpErrorStruct error);
     void returnNetworkError(const QString &download, NetworkErrorStruct error);
     void returnProcessError(const QString &download, ProcessErrorStruct error);
+    void returnAuthError(const QString &download, AuthErrorStruct error);
 
  protected:
     QDBusObjectPath registerDownload(Download* download) override;

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.cpp	2014-02-05 11:01:12 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.cpp	2014-02-19 18:29:41 +0000
@@ -33,6 +33,12 @@
     // destructor
 }
 
+void TestingManagerAdaptor::returnAuthError(const QString &download, AuthErrorStruct error)
+{
+    // handle method call com.canonical.applications.testing.DownloadManager.returnAuthError
+    QMetaObject::invokeMethod(parent(), "returnAuthError", Q_ARG(QString, download), Q_ARG(AuthErrorStruct, error));
+}
+
 void TestingManagerAdaptor::returnDBusErrors(bool returnErrors)
 {
     // handle method call com.canonical.applications.testing.DownloadManager.returnDBusErrors

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.h	2014-02-05 11:01:12 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/client/testing_manager_adaptor.h	2014-02-19 18:29:41 +0000
@@ -9,8 +9,8 @@
  * before re-generating it.
  */
 
-#ifndef TESTING_MANAGER_ADAPTOR_H_1391594312
-#define TESTING_MANAGER_ADAPTOR_H_1391594312
+#ifndef TESTING_MANAGER_ADAPTOR_H_1392305003
+#define TESTING_MANAGER_ADAPTOR_H_1392305003
 
 #include <QtCore/QObject>
 #include <QtDBus/QtDBus>
@@ -52,6 +52,11 @@
 "      <arg direction=\"in\" type=\"s\" name=\"download\"/>\n"
 "      <arg direction=\"in\" type=\"(isiss)\" name=\"error\"/>\n"
 "    </method>\n"
+"    <method name=\"returnAuthError\">\n"
+"      <annotation value=\"AuthErrorStruct\" name=\"org.qtproject.QtDBus.QtTypeName.In1\"/>\n"
+"      <arg direction=\"in\" type=\"s\" name=\"download\"/>\n"
+"      <arg direction=\"in\" type=\"(is)\" name=\"error\"/>\n"
+"    </method>\n"
 "  </interface>\n"
         "")
 public:
@@ -60,6 +65,7 @@
 
 public: // PROPERTIES
 public Q_SLOTS: // METHODS
+    void returnAuthError(const QString &download, AuthErrorStruct error);
     void returnDBusErrors(bool returnErrors);
     void returnHttpError(const QString &download, HttpErrorStruct error);
     void returnNetworkError(const QString &download, NetworkErrorStruct error);

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.cpp	2014-01-24 11:54:24 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.cpp	2014-02-19 18:29:41 +0000
@@ -135,3 +135,24 @@
     setState(Download::ERROR);
     emit error(errorMsg);
 }
+
+void
+FakeDownload::emitAuthError(AuthErrorStruct error) {
+    emit authError(error);
+}
+
+void
+FakeDownload::emitHttpError(HttpErrorStruct error) {
+    emit httpError(error);
+}
+
+void
+FakeDownload::emitNetworkError(NetworkErrorStruct error) {
+    emit networkError(error);
+}
+
+void
+FakeDownload::emitProcessError(ProcessErrorStruct error) {
+    emit processError(error);
+}
+

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.h	2014-01-28 18:51:12 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/download.h	2014-02-19 18:29:41 +0000
@@ -62,6 +62,10 @@
     // useful methods to emit signals
     void emitFinished(const QString& path);
     void emitError(const QString& error);
+    void emitAuthError(AuthErrorStruct error);
+    void emitHttpError(HttpErrorStruct error);
+    void emitNetworkError(NetworkErrorStruct error);
+    void emitProcessError(ProcessErrorStruct error);
 
     using Download::setAddToQueue;
 

=== added file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.cpp	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.cpp	2014-02-19 18:29:41 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "group_download.h"
+
+FakeGroupDownload::FakeGroupDownload(const QString& id,
+                                     const QString& path,
+                                     bool isConfined,
+                                     const QString& rootPath,
+                                     QList<GroupDownloadStruct> downloads,
+                                     const QString& algo,
+                                     bool isGSMDownloadAllowed,
+                                     const QVariantMap& metadata,
+                                     const QMap<QString, QString>& headers,
+                                     Factory* downFactory,
+                                     QObject* parent)
+    : GroupDownload(id, path, isConfined, rootPath, downloads, algo,
+           isGSMDownloadAllowed, metadata, headers, downFactory, parent) {
+}
+
+FakeDownload*
+FakeGroupDownload::downloadForUrl(const QString& url) {
+    // loop in the downloads and return a fake download if possible
+    // null otherwise
+    foreach(FileDownload* down, _downloads) {
+        if (down->url() == url) {
+            auto result = qobject_cast<FakeDownload*>(down);
+            return result;
+        }
+    }
+    return nullptr;
+}
+
+void
+FakeGroupDownload::emitAuthError(const QString& url, AuthErrorStruct error) {
+    auto down = downloadForUrl(url);
+    if (down != nullptr) {
+        down->emitAuthError(error);
+    }
+}
+
+void
+FakeGroupDownload::emitHttpError(const QString& url, HttpErrorStruct error) {
+    auto down = downloadForUrl(url);
+    if (down != nullptr) {
+        down->emitHttpError(error);
+    }
+}
+
+void
+FakeGroupDownload::emitNetworkError(const QString& url,
+                                    NetworkErrorStruct error) {
+    auto down = downloadForUrl(url);
+    if (down != nullptr) {
+        down->emitNetworkError(error);
+    }
+}
+
+void
+FakeGroupDownload::emitProcessError(const QString& url,
+                                    ProcessErrorStruct error) {
+    auto down = downloadForUrl(url);
+    if (down != nullptr) {
+        down->emitProcessError(error);
+    }
+}

=== added file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.h'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.h	1970-01-01 00:00:00 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/group_download.h	2014-02-19 18:29:41 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FAKE_GROUP_DOWNLOAD_H
+#define FAKE_GROUP_DOWNLOAD_H
+
+#include <downloads/group_download.h>
+#include "download.h"
+
+class FakeGroupDownload : public GroupDownload {
+    Q_OBJECT
+
+ public:
+    FakeGroupDownload(const QString& id,
+                      const QString& path,
+                      bool isConfined,
+                      const QString& rootPath,
+                      QList<GroupDownloadStruct> downloads,
+                      const QString& algo,
+                      bool isGSMDownloadAllowed,
+                      const QVariantMap& metadata,
+                      const QMap<QString, QString>& headers,
+                      Factory* downFactory,
+                      QObject* parent = 0);
+
+    void emitAuthError(const QString& url, AuthErrorStruct error);
+    void emitHttpError(const QString& url, HttpErrorStruct error);
+    void emitNetworkError(const QString& url, NetworkErrorStruct error);
+    void emitProcessError(const QString& url, ProcessErrorStruct error);
+
+ private:
+    FakeDownload* downloadForUrl(const QString& url);
+};
+
+#endif // GROUP_DOWNLOAD_H

=== modified file 'ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/network_reply.cpp'
--- ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/network_reply.cpp	2014-02-04 12:13:02 +0000
+++ ubuntu-download-manager-test-lib/ubuntu/download_manager/tests/server/network_reply.cpp	2014-02-19 18:29:41 +0000
@@ -127,7 +127,7 @@
 
 void
 FakeNetworkReply::emitHttpError(QNetworkReply::NetworkError code) {
-    emit error(code); 
+    emit error(code);
 }
 
 QVariant

=== modified file 'ubuntu-download-manager-tests/downloads/test_download.cpp'
--- ubuntu-download-manager-tests/downloads/test_download.cpp	2014-02-07 15:24:55 +0000
+++ ubuntu-download-manager-tests/downloads/test_download.cpp	2014-02-19 18:29:41 +0000
@@ -87,7 +87,7 @@
     QScopedPointer<FileDownload> download(new FileDownload(id, path, _isConfined,
         _rootPath, url, _metadata, _headers));
 
-    // assert that we did set the intial state correctly
+    // assert that we did set the initial state correctly
     // gets for internal state
 
     QCOMPARE(download->downloadId(), id);
@@ -144,7 +144,7 @@
 void
 TestDownload::testPath_data() {
     // create a number of rows with a diff path to ensure that
-    // the accesor does return the correct one
+    // the accessor does return the correct one
     QTest::addColumn<QString>("path");
     QTest::newRow("First row") << "/first/random/path";
     QTest::newRow("Second row") << "/second/random/path";
@@ -164,7 +164,7 @@
 void
 TestDownload::testUrl_data() {
     // create a number of rows with a diff url to ensure that
-    // the accesor does return the correct one
+    // the accessor does return the correct one
     QTest::addColumn<QUrl>("url");
     QTest::newRow("First row") << QUrl("http://ubuntu.com");
     QTest::newRow("Second row") << QUrl("http://one.ubuntu.com");
@@ -214,7 +214,7 @@
     reply->setData(fileData);
     emit reply->downloadProgress(received, total);
 
-    // assert that the total is set and that the signals is emited
+    // assert that the total is set and that the signals is emitted
     QCOMPARE(download->totalSize(), total);
     QCOMPARE(spy.count(), 1);
 
@@ -899,8 +899,8 @@
     // set the attrs in the reply so that we do raise two signals
     reply->setAttribute(QNetworkRequest::HttpStatusCodeAttribute, code);
     reply->setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, message);
-    
-    // emit the error and esure that the signals are raised
+
+    // emit the error and ensure that the signals are raised
     reply->emitHttpError(QNetworkReply::ContentAccessDenied);
     QCOMPARE(httpErrorSpy.count(), 1);
     QCOMPARE(errorSpy.count(), 1);
@@ -960,14 +960,70 @@
 
     // set the attrs in the reply so that we do raise two signals
     reply->clearAttribute(QNetworkRequest::HttpStatusCodeAttribute);
-    
-    // emit the error and esure that the signals are raised
+
+    // emit the error and ensure that the signals are raised
     reply->emitHttpError((QNetworkReply::NetworkError)code);
     QCOMPARE(networkErrorSpy.count(), 1);
     QCOMPARE(errorSpy.count(), 1);
 }
 
 void
+TestDownload::testOnAuthError() {
+    _reqFactory->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers));
+    QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
+    QSignalSpy authErrorSpy(download.data(),
+        SIGNAL(authError(AuthErrorStruct)));
+    QSignalSpy networkErrorSpy(download.data(),
+        SIGNAL(networkError(NetworkErrorStruct)));
+
+    download->start();  // change state
+    download->startDownload();
+
+    // we need to set the data before we pause!!!
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = reinterpret_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // emit the error and ensure that the signals are raised
+    reply->emitHttpError(QNetworkReply::AuthenticationRequiredError);
+    QCOMPARE(networkErrorSpy.count(), 0);
+    QCOMPARE(authErrorSpy.count(), 1);
+    auto error = authErrorSpy.takeFirst().at(0).value<AuthErrorStruct>();
+    QVERIFY(error.getType() == AuthErrorStruct::Server);
+    QCOMPARE(errorSpy.count(), 1);
+}
+
+void
+TestDownload::testOnProxyAuthError() {
+    _reqFactory->record();
+    QScopedPointer<FileDownload> download(new FileDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers));
+    QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
+    QSignalSpy authErrorSpy(download.data(),
+        SIGNAL(authError(AuthErrorStruct)));
+    QSignalSpy networkErrorSpy(download.data(),
+        SIGNAL(networkError(NetworkErrorStruct)));
+
+    download->start();  // change state
+    download->startDownload();
+
+    // we need to set the data before we pause!!!
+    QList<MethodData> calledMethods = _reqFactory->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    FakeNetworkReply* reply = reinterpret_cast<FakeNetworkReply*>(
+        calledMethods[0].params().outParams()[0]);
+
+    // emit the error and ensure that the signals are raised
+    reply->emitHttpError(QNetworkReply::ProxyAuthenticationRequiredError);
+    QCOMPARE(networkErrorSpy.count(), 0);
+    QCOMPARE(authErrorSpy.count(), 1);
+    QCOMPARE(errorSpy.count(), 1);
+}
+
+void
 TestDownload::testSetRawHeadersStart_data() {
     QTest::addColumn<QMap<QString, QString> >("headers");
 
@@ -1612,7 +1668,7 @@
 
     // emit the finished signal with a result > 0 and ensure error is emitted
     process->emitFinished(0, QProcess::NormalExit);
-    // asser that the file does not longer exist in the system
+    // assert that the file does not longer exist in the system
     QVERIFY(!QFile::exists(fileName));
 }
 
@@ -2014,7 +2070,7 @@
     reply->setAttribute(QNetworkRequest::RedirectionTargetAttribute,
         redirectUrl);
     QSignalSpy replySpy(_reqFactory, SIGNAL(requestCreated(NetworkReply*)));
-    
+
     // use a spy to wait for the second reply
     reply->emitFinished();
 
@@ -2024,7 +2080,7 @@
         replySpy.takeFirst().at(0).value<NetworkReply*>());
 
     download->pause();
-    
+
     // set the attr to be a loop
     reply->setAttribute(QNetworkRequest::RedirectionTargetAttribute,
         _url);
@@ -2062,7 +2118,7 @@
     reply->setAttribute(QNetworkRequest::RedirectionTargetAttribute,
         redirectUrl);
     QSignalSpy replySpy(_reqFactory, SIGNAL(requestCreated(NetworkReply*)));
-    
+
     // use a spy to wait for the second reply
     reply->emitFinished();
 
@@ -2073,7 +2129,7 @@
         replySpy.takeFirst().at(0).value<NetworkReply*>());
 
     download->pause();
-    
+
     QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
     QSignalSpy networkErrorSpy(download.data(),
         SIGNAL(networkError(NetworkErrorStruct)));
@@ -2138,7 +2194,7 @@
         reply->setAttribute(QNetworkRequest::RedirectionTargetAttribute,
             url);
         QSignalSpy replySpy(_reqFactory, SIGNAL(requestCreated(NetworkReply*)));
-        
+
         // use a spy to wait for the second reply
         reply->emitFinished();
 
@@ -2149,9 +2205,9 @@
             replySpy.takeFirst().at(0).value<NetworkReply*>());
         redirectCount++;
     }
-    
+
     download->pause();
-    
+
     QSignalSpy errorSpy(download.data(), SIGNAL(error(QString)));
     QSignalSpy networkErrorSpy(download.data(),
         SIGNAL(networkError(NetworkErrorStruct)));

=== modified file 'ubuntu-download-manager-tests/downloads/test_download.h'
--- ubuntu-download-manager-tests/downloads/test_download.h	2014-02-04 12:13:02 +0000
+++ ubuntu-download-manager-tests/downloads/test_download.h	2014-02-19 18:29:41 +0000
@@ -104,6 +104,8 @@
     void testOnSslError();
     void testOnNetworkError_data();
     void testOnNetworkError();
+    void testOnAuthError();
+    void testOnProxyAuthError();
     void testSetRawHeadersStart();
     void testSetRawHeadersWithRangeStart();
     void testSetRawHeadersResume();

=== modified file 'ubuntu-download-manager-tests/downloads/test_group_download.cpp'
--- ubuntu-download-manager-tests/downloads/test_group_download.cpp	2014-01-10 16:38:56 +0000
+++ ubuntu-download-manager-tests/downloads/test_group_download.cpp	2014-02-19 18:29:41 +0000
@@ -21,6 +21,7 @@
 #include <downloads/group_download.h>
 #include <system/uuid_utils.h>
 #include <ubuntu/download_manager/tests/server/download.h>
+#include <ubuntu/download_manager/tests/server/group_download.h>
 #include "test_group_download.h"
 
 TestGroupDownload::TestGroupDownload(QObject *parent)
@@ -870,3 +871,115 @@
 
     QVERIFY(!group->isValid());
 }
+
+void
+TestGroupDownload::testAuthErrorEmitted_data() {
+    QTest::addColumn<QString>("url");
+
+    QTest::newRow("First url") << "http://www.one.ubuntu.com";
+    QTest::newRow("Second url") << "http://ubuntu.com/file";
+}
+
+void
+TestGroupDownload::testAuthErrorEmitted() {
+    QFETCH(QString, url);
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct(url,
+        "first path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "second path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    QScopedPointer<FakeGroupDownload> group(new FakeGroupDownload(_id, _path,
+        false, _rootPath, downloadsStruct, "md5", _isGSMDownloadAllowed,
+        _metadata, _headers, _downloadFactory, _fileManager));
+
+    QSignalSpy spy(group.data(), SIGNAL(authError(QString, AuthErrorStruct)));
+    group->emitAuthError(url, AuthErrorStruct());
+    QCOMPARE(1, spy.count());
+}
+
+void
+TestGroupDownload::testHttpErrorEmitted_data() {
+    QTest::addColumn<QString>("url");
+
+    QTest::newRow("First url") << "http://www.one.ubuntu.com";
+    QTest::newRow("Second url") << "http://ubuntu.com/file";
+}
+
+void
+TestGroupDownload::testHttpErrorEmitted() {
+    QFETCH(QString, url);
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct(url,
+        "first path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "second path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    QScopedPointer<FakeGroupDownload> group(new FakeGroupDownload(_id, _path,
+        false, _rootPath, downloadsStruct, "md5", _isGSMDownloadAllowed,
+        _metadata, _headers, _downloadFactory, _fileManager));
+
+    QSignalSpy spy(group.data(), SIGNAL(httpError(QString, HttpErrorStruct)));
+    group->emitHttpError(url, HttpErrorStruct());
+    QCOMPARE(1, spy.count());
+}
+
+void
+TestGroupDownload::testNetworkErrorEmitted_data() {
+    QTest::addColumn<QString>("url");
+
+    QTest::newRow("First url") << "http://www.one.ubuntu.com";
+    QTest::newRow("Second url") << "http://ubuntu.com/file";
+}
+
+void
+TestGroupDownload::testNetworkErrorEmitted() {
+    QFETCH(QString, url);
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct(url,
+        "first path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "second path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    QScopedPointer<FakeGroupDownload> group(new FakeGroupDownload(_id, _path,
+        false, _rootPath, downloadsStruct, "md5", _isGSMDownloadAllowed,
+        _metadata, _headers, _downloadFactory, _fileManager));
+
+    QSignalSpy spy(group.data(), SIGNAL(networkError(QString, NetworkErrorStruct)));
+    group->emitNetworkError(url, NetworkErrorStruct());
+    QCOMPARE(1, spy.count());
+}
+
+void
+TestGroupDownload::testProcessErrorEmitted_data() {
+    QTest::addColumn<QString>("url");
+
+    QTest::newRow("First url") << "http://www.one.ubuntu.com";
+    QTest::newRow("Second url") << "http://ubuntu.com/file";
+}
+
+void
+TestGroupDownload::testProcessErrorEmitted() {
+    QFETCH(QString, url);
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct(url,
+        "first path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "second path", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    QScopedPointer<FakeGroupDownload> group(new FakeGroupDownload(_id, _path,
+        false, _rootPath, downloadsStruct, "md5", _isGSMDownloadAllowed,
+        _metadata, _headers, _downloadFactory, _fileManager));
+
+    QSignalSpy spy(group.data(), SIGNAL(processError(QString, ProcessErrorStruct)));
+    group->emitProcessError(url, ProcessErrorStruct());
+    QCOMPARE(1, spy.count());
+}

=== modified file 'ubuntu-download-manager-tests/downloads/test_group_download.h'
--- ubuntu-download-manager-tests/downloads/test_group_download.h	2014-01-10 16:38:56 +0000
+++ ubuntu-download-manager-tests/downloads/test_group_download.h	2014-02-19 18:29:41 +0000
@@ -87,6 +87,16 @@
     // ensure that local paths are just used once
     void testDuplicatedLocalPath();
 
+    // tests that ensure that the signals are raised
+    void testAuthErrorEmitted_data();
+    void testAuthErrorEmitted();
+    void testHttpErrorEmitted_data();
+    void testHttpErrorEmitted();
+    void testNetworkErrorEmitted_data();
+    void testNetworkErrorEmitted();
+    void testProcessErrorEmitted_data();
+    void testProcessErrorEmitted();
+
  private:
     QString _id;
     QString _path;