Merge lp:~mandel/ubuntu-download-manager/use-appid-local-path into lp:ubuntu-download-manager

[Manuel de la Peña]

Fixed the location where the file is stored. If the local-file metadata is provided and the app is not cofined that would be the used file else the XDG/APP_ID one will be used.

Fixed the location where the file is stored. If the local-file metadata is provided and the app is not cofined that would be the used file else the XDG/APP_ID one will be used.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:127
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/43/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-saucy-amd64-ci/43
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-saucy-armhf-ci/34

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

review: Approve (continuous-integration)

[Diego Sarmentero (diegosarmentero)]

+1 Look ok to me, just a little thing: Shouldn't we be using QStandardPaths instead of the implementation of xdg that we seem to be using here in part of the code? is xdg providing anything else that QStandardPaths+QDir is not doing?

review: Approve

[Manuel de la Peña (mandel)]

> +1 Look ok to me, just a little thing: Shouldn't we be using QStandardPaths
> instead of the implementation of xdg that we seem to be using here in part of
> the code? is xdg providing anything else that QStandardPaths+QDir is not
> doing?

You are correct, I was working without the QStandardPaths because they used not to support XDG in qt4 (or ealier) I'll create a branch to use QStandardPaths over the class I created in a diff branch.

[Mike McCracken (mikemc)]

1.
the reason for the needsfixing:
Unless I'm up too late, it looks like in download_factory.cpp, you've used an uninitialized
'bool isConfined' on lines 83, 103, and 124. I can't tell what the
intended default for those functions is, but the value will be
undefined. (see
e.g. http://stackoverflow.com/questions/4879045/fun-with-uninitialized-variables-and-compiler-gcc,
which references the C++ standard and has a funny example program.)

- related, I saw a lot of tests for those functions but couldn't
really tell if this issue was covered by tests. It'd be nice to create
a test that checks this and see what happens.
I saw in test_download.cpp and test_group_download.cpp, _isConfined is
just set to a single value for the whole class. would it make sense to use the
QTest::addColumn trick to have it run all those tests with both values?

2.
In AppArmor.h/.cpp, the the public API has "isContained" as the last
parameter of both versions of getSecurePath(), but the internal
versions call it 'isConfined'. they should probably all say
'isConfined'. (Not a needsfixing but it'd be nice if you have time to
fix it here)

3.
Not a branch blocker, but I found the download-factory API a little
awkward. Why is every function an overloaded version of
createDownload()? One version creates a group download, for example,
and the versions that you add in this branch have a comment about
being used to create 'from a group download', so they're different too
- why not use different names?

(One argument for using different names is that it's easier to grep
through the source that way)

review: Needs Fixing

[lp:~mandel/ubuntu-download-manager/use-appid-local-path]

128. By Manuel de la Peña on 2013-09-18

Made changes according to review.

[Mike McCracken (mikemc)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:128
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/50/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-saucy-amd64-ci/50
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-saucy-armhf-ci/41

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

review: Approve (continuous-integration)

=== modified file 'libubuntudownloadmanager/apparmor.cpp'
--- libubuntudownloadmanager/apparmor.cpp	2013-09-10 15:27:32 +0000
+++ libubuntudownloadmanager/apparmor.cpp	2013-09-18 10:19:27 +0000
@@ -24,6 +24,7 @@
 #include <QRegExp>
 #include "./dbus_proxy.h"
 #include "./uuid_factory.h"
+#include "./xdg_basedir.h"
 #include "./apparmor.h"
 
 /*
@@ -41,39 +42,77 @@
         _uuidFactory = new UuidFactory();
     }
 
-    QPair<QUuid, QString> getUuidString(QUuid id, QString path) {
+    QString getUuidPath(QUuid id, QString path) {
         qDebug() << __PRETTY_FUNCTION__ << path;
         QString idString = path + "/" + id.toString().replace(
             QRegExp("[-{}]"), "");
         qDebug() << "Download path is" << idString;
-        return QPair<QUuid, QString>(id, idString);
-    }
-
-    QPair<QUuid, QString> getSecurePath(QString connectionName) {
+        return idString;
+    }
+
+    void getDBusPath(QUuid& id, QString& dbusPath) {
+        id = _uuidFactory->createUuid();
+        dbusPath = getUuidPath(id, "");
+    }
+
+    QUuid getSecurePath(const QString& connName,
+                        QString& dbusPath,
+                        QString& localPath,
+                        bool& isConfined) {
         QUuid id = _uuidFactory->createUuid();
-        return getSecurePath(id, connectionName);
-    }
-
-    QPair<QUuid, QString> getSecurePath(QUuid id, QString connectionName) {
-        if (connectionName.isEmpty()) {
-            return getUuidString(id, QString(BASE_ACCOUNT_URL));
+        getSecurePath(connName, id, dbusPath, localPath, isConfined);
+        return id;
+    }
+
+    QString getLocalPath(const QString& appId) {
+        QStringList pathComponents;
+        if (!appId.isEmpty()) {
+            QStringList appIdInfo = appId.split("_");
+            if (appIdInfo.count() > 0)
+                pathComponents << appIdInfo[0];
+        }
+
+        pathComponents << "Downloads";
+        QString localPath = XDGBasedir::saveDataPath(pathComponents);
+        qDebug() << "Local path is" << localPath;
+        return localPath;
+    }
+
+    void getSecurePath(const QString& connName,
+                       const QUuid& id,
+                       QString& dbusPath,
+                       QString& localPath,
+                       bool& isConfined) {
+        if (connName.isEmpty()) {
+            dbusPath = getUuidPath(id, QString(BASE_ACCOUNT_URL));
+            localPath = getLocalPath("");
+            isConfined = false;
+            return;
         }
 
         QDBusPendingReply<QString> reply =
-            _dbus->GetConnectionAppArmorSecurityContext(connectionName);
+            _dbus->GetConnectionAppArmorSecurityContext(connName);
         // blocking but should be ok for now
         reply.waitForFinished();
         if (reply.isError()) {
             qCritical() << reply.error();
-            return getUuidString(id, QString(BASE_ACCOUNT_URL));
+            dbusPath = getUuidPath(id, QString(BASE_ACCOUNT_URL));
+            localPath = getLocalPath("");
+            isConfined = false;
+            return;
         } else {
             // use the returned value
             QString appId = reply.value();
             qDebug() << "AppId is " << appId;
 
             if (appId.isEmpty() || appId == UNCONFINED_ID) {
-                return getUuidString(id, QString(BASE_ACCOUNT_URL));
+                qDebug() << "UNCONFINED APP";
+                dbusPath = getUuidPath(id, QString(BASE_ACCOUNT_URL));
+                localPath = getLocalPath("");
+                isConfined = false;
+                return;
             } else {
+                isConfined = true;
                 QByteArray appIdBa = appId.toUtf8();
 
                 char * appIdPath;
@@ -83,14 +122,18 @@
                 if (appIdPath == NULL) {
                     qCritical() << "Unable to allocate memory for "
                         << "nih_dbus_path()";
-                    return getUuidString(id, QString(BASE_ACCOUNT_URL));
+                    dbusPath = getUuidPath(id, QString(BASE_ACCOUNT_URL));
+                    localPath = getLocalPath(appId);
+                    return;
                 }
                 QString path = QString(appIdPath);
                 qDebug() << "AppId path is " << appIdPath;
 
                 // free nih data
                 nih_free(appIdPath);
-                return getUuidString(id, path);
+                dbusPath = getUuidPath(id, path);
+                localPath = getLocalPath(appId);
+                return;
             }  // not empty appid string
         }  // no dbus error
     }
@@ -116,14 +159,27 @@
       d_ptr(new AppArmorPrivate(this)) {
 }
 
-QPair<QUuid, QString>
-AppArmor::getSecurePath(QString connectionName) {
-    Q_D(AppArmor);
-    return d->getSecurePath(connectionName);
-}
-
-QPair<QUuid, QString>
-AppArmor::getSecurePath(QUuid id, QString connectionName) {
-    Q_D(AppArmor);
-    return d->getSecurePath(id, connectionName);
+void
+AppArmor::getDBusPath(QUuid& id, QString& dbusPath) {
+    Q_D(AppArmor);
+    return d->getDBusPath(id, dbusPath);
+}
+
+QUuid
+AppArmor::getSecurePath(const QString& connName,
+                        QString& dbusPath,
+                        QString& localPath,
+                        bool& isConfined) {
+    Q_D(AppArmor);
+    return d->getSecurePath(connName, dbusPath, localPath, isConfined);
+}
+
+void
+AppArmor::getSecurePath(const QString& connName,
+                        const QUuid& id,
+                        QString& dbusPath,
+                        QString& localPath,
+                        bool& isConfined) {
+    Q_D(AppArmor);
+    d->getSecurePath(connName, id, dbusPath, localPath, isConfined);
 }

=== modified file 'libubuntudownloadmanager/apparmor.h'
--- libubuntudownloadmanager/apparmor.h	2013-09-10 15:27:32 +0000
+++ libubuntudownloadmanager/apparmor.h	2013-09-18 10:19:27 +0000
@@ -32,8 +32,17 @@
  public:
     explicit AppArmor(QObject *parent = 0);
 
-    virtual QPair<QUuid, QString> getSecurePath(QString connName);
-    virtual QPair<QUuid, QString> getSecurePath(QUuid id, QString connName);
+    virtual void getDBusPath(QUuid& id, QString& dbusPath);
+
+    virtual QUuid getSecurePath(const QString& connName,
+                                QString& dbusPath,
+                                QString& localPath,
+                                bool& isConfined);
+    virtual void getSecurePath(const QString& connName,
+                               const QUuid& id,
+                               QString& dbusPath,
+                               QString& localPath,
+                               bool& isConfined);
 
  private:
     // use pimpl so that we can mantains ABI compatibility

=== modified file 'libubuntudownloadmanager/download.cpp'
--- libubuntudownloadmanager/download.cpp	2013-09-09 16:05:49 +0000
+++ libubuntudownloadmanager/download.cpp	2013-09-18 10:19:27 +0000
@@ -30,6 +30,8 @@
  public:
     DownloadPrivate(const QUuid& id,
                     const QString& path,
+                    bool isConfined,
+                    const QString& rootPath,
                     const QVariantMap& metadata,
                     const QMap<QString, QString>& headers,
                     QSharedPointer<SystemNetworkInfo> networkInfo,
@@ -39,6 +41,8 @@
           _allowGSMDownload(true),
           _state(Download::IDLE),
           _dbusPath(path),
+          _isConfined(isConfined),
+          _rootPath(rootPath),
           _metadata(metadata),
           _headers(headers),
           _networkInfo(networkInfo),
@@ -58,6 +62,14 @@
         return _dbusPath;
     }
 
+    bool isConfined() const {
+        return _isConfined;
+    }
+
+    QString rootPath() const {
+        return _rootPath;
+    }
+
     Download::State state() {
         return _state;
     }
@@ -158,6 +170,8 @@
     bool _allowGSMDownload;
     Download::State _state;
     QString _dbusPath;
+    bool _isConfined;
+    QString _rootPath;
     QVariantMap _metadata;
     QMap<QString, QString> _headers;
     QSharedPointer<SystemNetworkInfo> _networkInfo;
@@ -171,13 +185,15 @@
 
 Download::Download(const QUuid& id,
                    const QString& path,
+                   bool isConfined,
+                   const QString& rootPath,
                    const QVariantMap& metadata,
                    const QMap<QString, QString>& headers,
                    QSharedPointer<SystemNetworkInfo> networkInfo,
                    QObject* parent)
     : QObject(parent),
-      d_ptr(new DownloadPrivate(id, path, metadata, headers,
-                  networkInfo, this)) {
+      d_ptr(new DownloadPrivate(id, path, isConfined, rootPath, metadata,
+            headers, networkInfo, this)) {
 }
 
 QUuid
@@ -192,6 +208,18 @@
     return d->path();
 }
 
+bool
+Download::isConfined() {
+    Q_D(Download);
+    return d->isConfined();
+}
+
+QString
+Download::rootPath() {
+    Q_D(Download);
+    return d->rootPath();
+}
+
 Download::State
 Download::state() {
     Q_D(Download);

=== modified file 'libubuntudownloadmanager/download.h'
--- libubuntudownloadmanager/download.h	2013-09-09 16:05:49 +0000
+++ libubuntudownloadmanager/download.h	2013-09-18 10:19:27 +0000
@@ -46,6 +46,8 @@
 
     Download(const QUuid& id,
              const QString& path,
+             bool isConfined,
+             const QString& rootPath,
              const QVariantMap& metadata,
              const QMap<QString, QString>& headers,
              QSharedPointer<SystemNetworkInfo> networkInfo,
@@ -55,6 +57,10 @@
 
     QString path();
 
+    bool isConfined();
+
+    QString rootPath();
+
     Download::State state();
     void setState(Download::State state);
 

=== modified file 'libubuntudownloadmanager/download_factory.cpp'
--- libubuntudownloadmanager/download_factory.cpp	2013-09-10 15:27:32 +0000
+++ libubuntudownloadmanager/download_factory.cpp	2013-09-18 10:19:27 +0000
@@ -24,6 +24,7 @@
 #include "./download_factory.h"
 
 #define OBJECT_PATH_KEY "objectpath"
+
 /*
  * PRIVATE IMPLEMENTATION
  */
@@ -46,22 +47,29 @@
           q_ptr(parent) {
     }
 
-    QPair<QUuid, QString> getDownloadPath(const QString& dbusOwner,
-                                          const QVariantMap& metadata) {
+    void getDownloadPath(const QString& dbusOwner,
+                         const QVariantMap& metadata,
+                         QUuid& id,
+                         QString& dbusPath,
+                         QString& rootPath,
+                         bool& isConfined) {
         qDebug() << __PRETTY_FUNCTION__ << dbusOwner << metadata;
         if (metadata.contains(OBJECT_PATH_KEY)) {
             // create a uuid using the string value form the metadata
-            QUuid id = QUuid(metadata[OBJECT_PATH_KEY].toString());
+            id = QUuid(metadata[OBJECT_PATH_KEY].toString());
             if (id.isNull()) {
                 qCritical() << "Uuid sent by client is NULL";
-                return _apparmor->getSecurePath(dbusOwner);
+                id = _apparmor->getSecurePath(dbusOwner, dbusPath, rootPath,
+                    isConfined);
             } else {
                 qDebug() << "Using the id from the client" << id;
-                return _apparmor->getSecurePath(id, dbusOwner);
+                _apparmor->getSecurePath(dbusOwner, id, dbusPath, rootPath,
+                    isConfined);
             }
         } else {
             qDebug() << "DownloadFactory assigns the Download Uuid.";
-            return _apparmor->getSecurePath(dbusOwner);
+            id = _apparmor->getSecurePath(dbusOwner, dbusPath, rootPath,
+                isConfined);
         }
     }
 
@@ -69,9 +77,15 @@
                              const QUrl& url,
                              const QVariantMap& metadata,
                              const QMap<QString, QString>& headers) {
-        QPair<QUuid, QString> idData = getDownloadPath(dbusOwner, metadata);
-        Download* down = new SingleDownload(idData.first, idData.second, url,
-            metadata, headers, _networkInfo, _nam, _processFactory);
+        QUuid id;
+        QString dbusPath;
+        QString rootPath;
+        bool isConfined = false;
+        getDownloadPath(dbusOwner, metadata, id, dbusPath, rootPath,
+            isConfined);
+        qDebug() << "Download secure data is " << id << dbusPath << rootPath;
+        Download* down = new SingleDownload(id, dbusPath, isConfined, rootPath,
+            url, metadata, headers, _networkInfo, _nam, _processFactory);
         DownloadAdaptor* adaptor = new DownloadAdaptor(down);
         down->setAdaptor(adaptor);
         return down;
@@ -83,9 +97,15 @@
                              QCryptographicHash::Algorithm algo,
                              const QVariantMap& metadata,
                              const QMap<QString, QString>& headers) {
-        QPair<QUuid, QString> idData = getDownloadPath(dbusOwner, metadata);
-        Download* down = new SingleDownload(idData.first, idData.second, url,
-            hash, algo, metadata, headers, _networkInfo, _nam,
+        QUuid id;
+        QString dbusPath;
+        QString rootPath;
+        bool isConfined = false;
+        getDownloadPath(dbusOwner, metadata, id, dbusPath, rootPath,
+            isConfined);
+        qDebug() << "Download secure data is " << id << dbusPath << rootPath;
+        Download* down = new SingleDownload(id, dbusPath, isConfined,
+            rootPath, url, hash, algo, metadata, headers, _networkInfo, _nam,
             _processFactory);
         DownloadAdaptor* adaptor = new DownloadAdaptor(down);
         down->setAdaptor(adaptor);
@@ -98,8 +118,14 @@
                              bool allowed3G,
                              const QVariantMap& metadata,
                              StringMap headers) {
-        QPair<QUuid, QString> idData = getDownloadPath(dbusOwner, metadata);
-        Download* down = new GroupDownload(idData.first, idData.second,
+        QUuid id;
+        QString dbusPath;
+        QString rootPath;
+        bool isConfined = false;
+        getDownloadPath(dbusOwner, metadata, id, dbusPath, rootPath,
+            isConfined);
+        qDebug() << "Download secure data is " << id << dbusPath << rootPath;
+        Download* down = new GroupDownload(id, dbusPath, isConfined, rootPath,
             downloads, algo, allowed3G, metadata, headers, _networkInfo,
             _self);
         GroupDownloadAdaptor* adaptor = new GroupDownloadAdaptor(down);
@@ -107,6 +133,39 @@
         return down;
     }
 
+    Download* createDownloadForGroup(bool isConfined,
+                                     const QString& rootPath,
+                                     const QUrl& url,
+                                     const QVariantMap& metadata,
+                                     const QMap<QString, QString>& headers) {
+        QUuid id;
+        QString dbusPath;
+        _apparmor->getDBusPath(id, dbusPath);
+        Download* down = new SingleDownload(id, dbusPath, isConfined, rootPath,
+            url, metadata, headers, _networkInfo, _nam, _processFactory);
+        DownloadAdaptor* adaptor = new DownloadAdaptor(down);
+        down->setAdaptor(adaptor);
+        return down;
+    }
+
+    Download* createDownloadForGroup(bool isConfined,
+                                     const QString& rootPath,
+                                     const QUrl& url,
+                                     const QString& hash,
+                                     QCryptographicHash::Algorithm algo,
+                                     const QVariantMap& metadata,
+                                     const QMap<QString, QString>& headers) {
+        QUuid id;
+        QString dbusPath;
+        _apparmor->getDBusPath(id, dbusPath);
+        Download* down = new SingleDownload(id, dbusPath, isConfined,
+            rootPath, url, hash, algo, metadata, headers, _networkInfo, _nam,
+            _processFactory);
+        DownloadAdaptor* adaptor = new DownloadAdaptor(down);
+        down->setAdaptor(adaptor);
+        return down;
+    }
+
  private:
     QSharedPointer<AppArmor> _apparmor;
     QSharedPointer<SystemNetworkInfo> _networkInfo;
@@ -162,3 +221,27 @@
     return d->createDownload(dbusOwner, downloads, algo, allowed3G, metadata,
         headers);
 }
+
+Download*
+DownloadFactory::createDownloadForGroup(bool isConfined,
+                                        const QString& rootPath,
+                                        const QUrl& url,
+                                        const QVariantMap& metadata,
+                                        const QMap<QString, QString>& headers) {
+    Q_D(DownloadFactory);
+    return d->createDownloadForGroup(isConfined, rootPath, url, metadata,
+        headers);
+}
+
+Download*
+DownloadFactory::createDownloadForGroup(bool isConfined,
+                                        const QString& rootPath,
+                                        const QUrl& url,
+                                        const QString& hash,
+                                        QCryptographicHash::Algorithm algo,
+                                        const QVariantMap& metadata,
+                                        const QMap<QString, QString>& headers) {
+    Q_D(DownloadFactory);
+    return d->createDownloadForGroup(isConfined, rootPath, url, hash, algo,
+        metadata, headers);
+}

=== modified file 'libubuntudownloadmanager/download_factory.h'
--- libubuntudownloadmanager/download_factory.h	2013-09-10 12:18:34 +0000
+++ libubuntudownloadmanager/download_factory.h	2013-09-18 10:19:27 +0000
@@ -40,6 +40,8 @@
                     QSharedPointer<ProcessFactory> processFactory,
                     QObject *parent = 0);
 
+    // create downloads comming from a dbus call
+
     virtual Download* createDownload(const QString& dbusOwner,
                                      const QUrl& url,
                                      const QVariantMap& metadata,
@@ -59,6 +61,22 @@
                                      const QVariantMap& metadata,
                                      StringMap headers);
 
+    // create downloads from a group download
+
+    virtual Download* createDownloadForGroup(bool isConfined,
+                                         const QString& rootPath,
+                                         const QUrl& url,
+                                         const QVariantMap& metadata,
+                                         const QMap<QString, QString>& headers);
+
+    virtual Download* createDownloadForGroup(bool isConfined,
+                                         const QString& rootPath,
+                                         const QUrl& url,
+                                         const QString& hash,
+                                         QCryptographicHash::Algorithm algo,
+                                         const QVariantMap& metadata,
+                                         const QMap<QString, QString>& headers);
+
  private:
     // use pimpl so that we can mantains ABI compatibility
     DownloadFactoryPrivate* d_ptr;

=== modified file 'libubuntudownloadmanager/group_download.cpp'
--- libubuntudownloadmanager/group_download.cpp	2013-09-10 12:18:34 +0000
+++ libubuntudownloadmanager/group_download.cpp	2013-09-18 10:19:27 +0000
@@ -80,15 +80,22 @@
             QString hash = download.getHash();
 
             SingleDownload* singleDownload;
+            QVariantMap downloadMetadata = QVariantMap(metadata);
+            downloadMetadata[LOCAL_PATH_KEY] = download.getLocalFile();
+            qDebug() << "Download metadata is" << downloadMetadata;
+            qDebug() << "Group metadata is" << metadata;
+
             if (hash.isEmpty()) {
                 qDebug() << "Creating SingleDownload with no hash.";
                 singleDownload = qobject_cast<SingleDownload*>(
-                    _downFactory->createDownload("", url, metadata, headers));
+                    _downFactory->createDownloadForGroup(q->isConfined(),
+                        q->rootPath(), url, downloadMetadata, headers));
             } else {
                 qDebug() << "Creating SingleDownload with hash.";
                 singleDownload = qobject_cast<SingleDownload*>(
-                    _downFactory->createDownload("", url, hash, algo, metadata,
-                    headers));
+                    _downFactory->createDownloadForGroup(q->isConfined(),
+                        q->rootPath(), url, hash, algo, downloadMetadata,
+                        headers));
             }
 
             singleDownload->allowGSMDownload(isGSMDownloadAllowed);
@@ -223,7 +230,7 @@
         Q_Q(GroupDownload);
         SingleDownload* sender = qobject_cast<SingleDownload*>(q->sender());
         qDebug() << __PRETTY_FUNCTION__;
-        // TODO (mandel): the result is not real, we need to be smarter make
+        // TODO(mandel): the result is not real, we need to be smarter make
         // a head request get size and name and the do all this, but atm is
         // 'good enough' get the sender and check if we received
         // progress from it, update its data and recanculate
@@ -292,6 +299,8 @@
 
 GroupDownload::GroupDownload(const QUuid& id,
                   const QString& path,
+                  bool isConfined,
+                  const QString& rootPath,
                   QList<GroupDownloadStruct> downloads,
                   QCryptographicHash::Algorithm algo,
                   bool isGSMDownloadAllowed,
@@ -300,13 +309,16 @@
                   QSharedPointer<SystemNetworkInfo> networkInfo,
                   QSharedPointer<DownloadFactory> downFactory,
                   QObject* parent)
-    : Download(id, path, metadata, headers, networkInfo, parent),
+    : Download(id, path, isConfined, rootPath, metadata, headers,
+            networkInfo, parent),
       d_ptr(new GroupDownloadPrivate(downloads, algo, isGSMDownloadAllowed,
             networkInfo, downFactory, this)) {
 }
 
 GroupDownload::GroupDownload(const QUuid& id,
                   const QString& path,
+                  bool isConfined,
+                  const QString& rootPath,
                   QList<GroupDownloadStruct> downloads,
                   QCryptographicHash::Algorithm algo,
                   bool isGSMDownloadAllowed,
@@ -316,7 +328,8 @@
                   QSharedPointer<DownloadFactory> downFactory,
                   QSharedPointer<FileManager> fileManager,
                   QObject* parent)
-    : Download(id, path, metadata, headers, networkInfo, parent),
+    : Download(id, path, isConfined, rootPath, metadata, headers,
+            networkInfo, parent),
       d_ptr(new GroupDownloadPrivate(downloads, algo, isGSMDownloadAllowed,
             networkInfo, downFactory, fileManager, this)) {
 }

=== modified file 'libubuntudownloadmanager/group_download.h'
--- libubuntudownloadmanager/group_download.h	2013-09-10 12:18:34 +0000
+++ libubuntudownloadmanager/group_download.h	2013-09-18 10:19:27 +0000
@@ -36,6 +36,8 @@
  public:
     GroupDownload(const QUuid& id,
                   const QString& path,
+                  bool isConfined,
+                  const QString& rootPath,
                   QList<GroupDownloadStruct> downloads,
                   QCryptographicHash::Algorithm algo,
                   bool isGSMDownloadAllowed,
@@ -47,6 +49,8 @@
 
     GroupDownload(const QUuid& id,
                   const QString& path,
+                  bool isConfined,
+                  const QString& rootPath,
                   QList<GroupDownloadStruct> downloads,
                   QCryptographicHash::Algorithm algo,
                   bool isGSMDownloadAllowed,

=== modified file 'libubuntudownloadmanager/single_download.cpp'
--- libubuntudownloadmanager/single_download.cpp	2013-09-09 16:05:49 +0000
+++ libubuntudownloadmanager/single_download.cpp	2013-09-18 10:19:27 +0000
@@ -85,9 +85,7 @@
     }
 
     QString filePath() {
-        if (_currentData)
-            return _currentData->fileName();
-        return saveFileName();
+        return _filePath;
     }
 
     QString hash() const {
@@ -188,7 +186,7 @@
         qDebug() << "Starting download.";
         // create file that will be used to mantain the state of the
         // download when resumed.
-        _currentData = new QFile(saveFileName());
+        _currentData = new QFile(_filePath);
         _currentData->open(QIODevice::ReadWrite | QFile::Append);
 
         // signals should take care or calling deleteLater on the
@@ -356,12 +354,8 @@
 
  private:
     void init() {
-        Q_Q(SingleDownload);
-        QStringList pathComponents;
-        pathComponents << "download_manager" << q->downloadId().toString();
-        _localPath = XDGBasedir::saveDataPath(pathComponents);
-        qDebug() << "File will be downloaded to" << _localPath;
-
+        _filePath = saveFileName();
+        qDebug() << "Download path is" << _filePath;
         _reply = NULL;
         _currentData = NULL;
     }
@@ -395,39 +389,25 @@
     }
 
     QString saveFileName() {
+        Q_Q(SingleDownload);
+
         QString path = _url.path();
         QString basename = QFileInfo(path).fileName();
 
         if (basename.isEmpty())
             basename = DATA_FILE_NAME;
 
-        QString final_path = _localPath + QDir::separator() + basename;
-        return final_path;
-    }
-
-    bool removeDir(const QString& dirName) {
-        bool result = true;
-        QDir dir(dirName);
-
-        QFlags<QDir::Filter> filter =  QDir::NoDotAndDotDot | QDir::System
-            | QDir::Hidden  | QDir::AllDirs | QDir::Files;
-        if (dir.exists(dirName)) {
-            foreach(QFileInfo info,
-                    dir.entryInfoList(filter, QDir::DirsFirst)) {
-                if (info.isDir()) {
-                result = removeDir(info.absoluteFilePath());
-                } else {
-                    result = QFile::remove(info.absoluteFilePath());
-                }
-
-                if (!result) {
-                    return result;
-                }
-            }
-            result = dir.rmdir(dirName);
+        QVariantMap metadata = q->metadata();
+        QString finalPath;
+
+        if (!q->isConfined() && metadata.contains(LOCAL_PATH_KEY)) {
+            qDebug() << "App is not confined and provided a local path";
+            finalPath = metadata[LOCAL_PATH_KEY].toString();
+        } else {
+            finalPath = q->rootPath() + QDir::separator() + basename;
         }
 
-        return result;
+        return finalPath;
     }
 
     void cleanUpCurrentData() {
@@ -442,9 +422,9 @@
             if (!success)
                 qWarning() << "Error removing" << fileName;
         }
-        success = removeDir(_localPath);
+        success = QFile::remove(_filePath);
         if (!success)
-            qWarning() << "Error removing" << _localPath;
+            qWarning() << "Error removing" << _filePath;
     }
 
     QNetworkRequest buildRequest() {
@@ -474,8 +454,8 @@
 
  private:
     qulonglong _totalSize;
-    QString _localPath;
     QUrl _url;
+    QString _filePath;
     QString _hash;
     QCryptographicHash::Algorithm _algo;
     NetworkReply* _reply;
@@ -491,6 +471,8 @@
 
 SingleDownload::SingleDownload(const QUuid& id,
                    const QString& path,
+                   bool isConfined,
+                   const QString& rootPath,
                    const QUrl& url,
                    const QVariantMap& metadata,
                    const QMap<QString, QString>& headers,
@@ -498,12 +480,15 @@
                    QSharedPointer<RequestFactory> nam,
                    QSharedPointer<ProcessFactory> processFactory,
                    QObject* parent)
-    : Download(id, path, metadata, headers, networkInfo, parent),
+    : Download(id, path, isConfined, rootPath, metadata, headers, networkInfo,
+            parent),
       d_ptr(new SingleDownloadPrivate(url, nam, processFactory, this)) {
 }
 
 SingleDownload::SingleDownload(const QUuid& id,
                    const QString& path,
+                   bool isConfined,
+                   const QString& rootPath,
                    const QUrl& url,
                    const QString& hash,
                    QCryptographicHash::Algorithm algo,
@@ -513,7 +498,8 @@
                    QSharedPointer<RequestFactory> nam,
                    QSharedPointer<ProcessFactory> processFactory,
                    QObject* parent)
-    : Download(id, path, metadata, headers, networkInfo, parent),
+    : Download(id, path, isConfined, rootPath, metadata, headers, networkInfo,
+            parent),
       d_ptr(new SingleDownloadPrivate(url, hash, algo, nam,
             processFactory, this)) {
 }

=== modified file 'libubuntudownloadmanager/single_download.h'
--- libubuntudownloadmanager/single_download.h	2013-09-09 16:05:49 +0000
+++ libubuntudownloadmanager/single_download.h	2013-09-18 10:19:27 +0000
@@ -28,6 +28,8 @@
 #include "./app-downloader-lib_global.h"
 #include "./download.h"
 
+#define LOCAL_PATH_KEY "local-path"
+
 class SingleDownloadPrivate;
 class APPDOWNLOADERLIBSHARED_EXPORT SingleDownload : public Download {
     Q_OBJECT
@@ -36,6 +38,8 @@
  public:
     SingleDownload(const QUuid& id,
                    const QString& path,
+                   bool isConfined,
+                   const QString& rootPath,
                    const QUrl& url,
                    const QVariantMap& metadata,
                    const QMap<QString, QString>& headers,
@@ -45,6 +49,8 @@
                    QObject* parent = 0);
     SingleDownload(const QUuid& id,
                    const QString& path,
+                   bool isConfined,
+                   const QString& rootPath,
                    const QUrl& url,
                    const QString& hash,
                    QCryptographicHash::Algorithm algo,

=== modified file 'ubuntu-download-manager-tests/fake_apparmor.cpp'
--- ubuntu-download-manager-tests/fake_apparmor.cpp	2013-09-10 15:27:32 +0000
+++ ubuntu-download-manager-tests/fake_apparmor.cpp	2013-09-18 10:19:27 +0000
@@ -21,31 +21,46 @@
 FakeAppArmor::FakeAppArmor(QSharedPointer<UuidFactory> uuidFactory,
                            QObject *parent)
     : AppArmor(parent),
+      _isConfined(true),
       _uuidFactory(uuidFactory) {
 }
 
-QPair<QUuid, QString>
-FakeAppArmor::getSecurePath(QString connName) {
+void
+FakeAppArmor::getDBusPath(QUuid& id, QString& dbusPath) {
+    id = _uuidFactory->createUuid();
+    dbusPath = id.toString().replace(QRegExp("[-{}]"), "");
+    if (_recording) {
+        QList<QObject*> inParams;
+
+        QList<QObject*> outParams;
+        outParams.append(new UuidWrapper(id));
+        outParams.append(new StringWrapper(dbusPath));
+        MethodParams params(inParams, outParams);
+        MethodData methodData("getDBusPath", params);
+        _called.append(methodData);
+    }
+}
+
+QUuid
+FakeAppArmor::getSecurePath(const QString& connName,
+                        QString& dbusPath,
+                        QString& localPath,
+                        bool& isConfined) {
     QUuid id = _uuidFactory->createUuid();
-    QString uuidString = id.toString().replace(QRegExp("[-{}]"), "");
-    if (_recording) {
-        QList<QObject*> inParams;
-        inParams.append(new StringWrapper(connName));
-
-        QList<QObject*> outParams;
-        outParams.append(new UuidWrapper(id));
-        outParams.append(new StringWrapper(uuidString));
-        MethodParams params(inParams, outParams);
-        MethodData methodData("getSecurePath", params);
-        _called.append(methodData);
-    }
-
-    return QPair<QUuid, QString>(id, uuidString);
+    getSecurePath(connName, id, dbusPath, localPath, isConfined);
+    return id;
 }
 
-QPair<QUuid, QString>
-FakeAppArmor::getSecurePath(QUuid id, QString connName) {
+void
+FakeAppArmor::getSecurePath(const QString& connName,
+                       const QUuid& id,
+                       QString& dbusPath,
+                       QString& localPath,
+                       bool& isConfined) {
     QString uuidString = id.toString().replace(QRegExp("[-{}]"), "");
+    dbusPath = "dbus/" + uuidString;
+    localPath = "local/"+ uuidString;
+    isConfined = _isConfined;
     if (_recording) {
         QList<QObject*> inParams;
         inParams.append(new UuidWrapper(id));
@@ -53,11 +68,20 @@
 
         QList<QObject*> outParams;
         outParams.append(new UuidWrapper(id));
-        outParams.append(new StringWrapper(uuidString));
+        outParams.append(new StringWrapper(dbusPath));
+        outParams.append(new StringWrapper(localPath));
         MethodParams params(inParams, outParams);
         MethodData methodData("getSecurePath", params);
         _called.append(methodData);
     }
-
-    return QPair<QUuid, QString>(id, uuidString);
+}
+
+bool
+FakeAppArmor::isConfined() {
+    return _isConfined;
+}
+
+void
+FakeAppArmor::setIsConfined() {
+    _isConfined = true;
 }

=== modified file 'ubuntu-download-manager-tests/fake_apparmor.h'
--- ubuntu-download-manager-tests/fake_apparmor.h	2013-09-10 15:27:32 +0000
+++ ubuntu-download-manager-tests/fake_apparmor.h	2013-09-18 10:19:27 +0000
@@ -31,10 +31,23 @@
     FakeAppArmor(QSharedPointer<UuidFactory> uuidFactory,
                  QObject *parent = 0);
 
-    QPair<QUuid, QString> getSecurePath(QString connName) override;
-    QPair<QUuid, QString> getSecurePath(QUuid id, QString connName) override;
+    void getDBusPath(QUuid& id, QString& dbusPath) override;
+
+    QUuid getSecurePath(const QString& connName,
+                        QString& dbusPath,
+                        QString& localPath,
+                        bool& isConfined) override;
+    void getSecurePath(const QString& connName,
+                       const QUuid& id,
+                       QString& dbusPath,
+                       QString& localPath,
+                       bool& isConfined) override;
+
+    bool isConfined();
+    void setIsConfined();
 
  private:
+    bool _isConfined;
     QSharedPointer<UuidFactory> _uuidFactory;
 };
 

=== modified file 'ubuntu-download-manager-tests/fake_download.cpp'
--- ubuntu-download-manager-tests/fake_download.cpp	2013-09-09 16:05:49 +0000
+++ ubuntu-download-manager-tests/fake_download.cpp	2013-09-18 10:19:27 +0000
@@ -21,6 +21,8 @@
 
 FakeDownload::FakeDownload(const QUuid& id,
                            const QString& path,
+                           bool isConfined,
+                           const QString& rootPath,
                            const QUrl& url,
                            const QVariantMap& metadata,
                            const QMap<QString, QString> &headers,
@@ -28,13 +30,15 @@
                            QSharedPointer<RequestFactory> nam,
                            QSharedPointer<ProcessFactory> processFactory,
                            QObject* parent)
-        : SingleDownload(id, path, url, metadata, headers, networkInfo, nam,
-                processFactory, parent),
+        : SingleDownload(id, path, isConfined, rootPath, url, metadata,
+                headers, networkInfo, nam, processFactory, parent),
         _canDownload(true) {
 }
 
 FakeDownload::FakeDownload(const QUuid& id,
                            const QString& path,
+                           bool isConfined,
+                           const QString& rootPath,
                            const QUrl& url,
                            const QString& hash,
                            QCryptographicHash::Algorithm algo,
@@ -44,8 +48,8 @@
                            QSharedPointer<RequestFactory> nam,
                            QSharedPointer<ProcessFactory> processFactory,
                            QObject* parent)
-        : SingleDownload(id, path, url, hash, algo, metadata, headers,
-                networkInfo, nam, processFactory, parent),
+        : SingleDownload(id, path, isConfined, rootPath, url, hash, algo,
+                metadata, headers, networkInfo, nam, processFactory, parent),
         _canDownload(true) {
 }
 

=== modified file 'ubuntu-download-manager-tests/fake_download.h'
--- ubuntu-download-manager-tests/fake_download.h	2013-09-09 16:05:49 +0000
+++ ubuntu-download-manager-tests/fake_download.h	2013-09-18 10:19:27 +0000
@@ -28,26 +28,30 @@
     Q_OBJECT
 
  public:
-    explicit FakeDownload(const QUuid& id,
-                          const QString& path,
-                          const QUrl& url,
-                          const QVariantMap& metadata,
-                          const QMap<QString, QString>& headers,
-                          QSharedPointer<SystemNetworkInfo> networkInfo,
-                          QSharedPointer<RequestFactory> nam,
-                          QSharedPointer<ProcessFactory> processFactory,
-                          QObject* parent = 0);
-    explicit FakeDownload(const QUuid& id,
-                          const QString& path,
-                          const QUrl& url,
-                          const QString& hash,
-                          QCryptographicHash::Algorithm algo,
-                          const QVariantMap& metadata,
-                          const QMap<QString, QString> &headers,
-                          QSharedPointer<SystemNetworkInfo> networkInfo,
-                          QSharedPointer<RequestFactory> nam,
-                          QSharedPointer<ProcessFactory> processFactory,
-                          QObject* parent = 0);
+    FakeDownload(const QUuid& id,
+                 const QString& path,
+                 bool isConfined,
+                 const QString& rootPath,
+                 const QUrl& url,
+                 const QVariantMap& metadata,
+                 const QMap<QString, QString>& headers,
+                 QSharedPointer<SystemNetworkInfo> networkInfo,
+                 QSharedPointer<RequestFactory> nam,
+                 QSharedPointer<ProcessFactory> processFactory,
+                 QObject* parent = 0);
+    FakeDownload(const QUuid& id,
+                 const QString& path,
+                 bool isConfined,
+                 const QString& rootPath,
+                 const QUrl& url,
+                 const QString& hash,
+                 QCryptographicHash::Algorithm algo,
+                 const QVariantMap& metadata,
+                 const QMap<QString, QString> &headers,
+                 QSharedPointer<SystemNetworkInfo> networkInfo,
+                 QSharedPointer<RequestFactory> nam,
+                 QSharedPointer<ProcessFactory> processFactory,
+                 QObject* parent = 0);
 
     bool canDownload() override;
     void setCanDownload(bool canDownload);

=== modified file 'ubuntu-download-manager-tests/fake_download_factory.cpp'
--- ubuntu-download-manager-tests/fake_download_factory.cpp	2013-09-10 12:18:34 +0000
+++ ubuntu-download-manager-tests/fake_download_factory.cpp	2013-09-18 10:19:27 +0000
@@ -38,15 +38,21 @@
                                     const QUrl& url,
                                     const QVariantMap& metadata,
                                     const QMap<QString, QString>& headers) {
+    qDebug() << __PRETTY_FUNCTION__;
     if (_recording) {
         MethodData methodData;
         methodData.setMethodName("createDownload");
         _called.append(methodData);
     }
-    QPair<QUuid, QString> idData = _apparmor->getSecurePath(downloadOwner);
-    Download* down = new FakeDownload(idData.first, idData.second, url,
+    QString dbusPath;
+    QString rootPath;
+    bool isConfined;
+    QUuid id = _apparmor->getSecurePath(downloadOwner, dbusPath, rootPath,
+        isConfined);
+    Download* down = new FakeDownload(id, dbusPath, isConfined, rootPath, url,
         metadata, headers, _networkInfo, _nam, _processFactory);
     _downloads.append(down);
+    qDebug() << "Downloads count" << _downloads.count();
     return down;
 }
 
@@ -57,15 +63,21 @@
                                     QCryptographicHash::Algorithm algo,
                                     const QVariantMap& metadata,
                                     const QMap<QString, QString>& headers) {
+    qDebug() << __PRETTY_FUNCTION__;
     if (_recording) {
         MethodData methodData;
         methodData.setMethodName("createDownload");
         _called.append(methodData);
     }
-    QPair<QUuid, QString> idData = _apparmor->getSecurePath(downloadOwner);
-    Download* down = new FakeDownload(idData.first, idData.second, url,
+    QString dbusPath;
+    QString rootPath;
+    bool isConfined;
+    QUuid id = _apparmor->getSecurePath(downloadOwner, dbusPath, rootPath,
+        isConfined);
+    Download* down = new FakeDownload(id, dbusPath, isConfined, rootPath, url,
         hash, algo, metadata, headers, _networkInfo, _nam, _processFactory);
     _downloads.append(down);
+    qDebug() << "Downloads count" << _downloads.count();
     return down;
 }
 
@@ -76,6 +88,7 @@
                                     bool allowed3G,
                                     const QVariantMap& metadata,
                                     StringMap headers) {
+    qDebug() << __PRETTY_FUNCTION__;
     Q_UNUSED(allowed3G);
     Q_UNUSED(downloads);
     if (_recording) {
@@ -83,11 +96,58 @@
         methodData.setMethodName("createDownload");
         _called.append(methodData);
     }
-    QPair<QUuid, QString> idData = _apparmor->getSecurePath(downloadOwner);
-    Download* down = new FakeDownload(idData.first, idData.second,
+
+    QString dbusPath;
+    QString rootPath;
+    bool isConfined;
+    QUuid id = _apparmor->getSecurePath(downloadOwner, dbusPath, rootPath,
+        isConfined);
+    Download* down = new FakeDownload(id, dbusPath, isConfined, rootPath,
         QUrl(), "", algo, metadata, headers, _networkInfo, _nam,
         _processFactory);
     _downloads.append(down);
+    qDebug() << "Downloads count" << _downloads.count();
+    return down;
+}
+
+Download*
+FakeDownloadFactory::createDownloadForGroup(bool isConfined,
+                                    const QString& rootPath,
+                                    const QUrl& url,
+                                    const QVariantMap& metadata,
+                                    const QMap<QString, QString>& headers)  {
+    qDebug() << __PRETTY_FUNCTION__;
+    if (_recording) {
+        MethodData methodData;
+        methodData.setMethodName("createDownload");
+        _called.append(methodData);
+    }
+    QUuid id;
+    QString dbusPath;
+    _apparmor->getDBusPath(id, dbusPath);
+    Download* down = new FakeDownload(id, dbusPath, isConfined, rootPath,
+        url, metadata, headers, _networkInfo, _nam, _processFactory);
+    _downloads.append(down);
+    qDebug() << "Downloads count" << _downloads.count();
+    return down;
+}
+
+Download*
+FakeDownloadFactory::createDownloadForGroup(bool isConfined,
+                                    const QString& rootPath,
+                                    const QUrl& url,
+                                    const QString& hash,
+                                    QCryptographicHash::Algorithm algo,
+                                    const QVariantMap& metadata,
+                                    const QMap<QString, QString>& headers) {
+    QUuid id;
+    QString dbusPath;
+    _apparmor->getDBusPath(id, dbusPath);
+    Download* down = new SingleDownload(id, dbusPath, isConfined,
+        rootPath, url, hash, algo, metadata, headers, _networkInfo, _nam,
+        _processFactory);
+    _downloads.append(down);
+    qDebug() << "Downloads count" << _downloads.count();
     return down;
 }
 

=== modified file 'ubuntu-download-manager-tests/fake_download_factory.h'
--- ubuntu-download-manager-tests/fake_download_factory.h	2013-09-10 12:18:34 +0000
+++ ubuntu-download-manager-tests/fake_download_factory.h	2013-09-18 10:19:27 +0000
@@ -53,6 +53,20 @@
                              const QVariantMap& metadata,
                              StringMap headers) override;
 
+    Download* createDownloadForGroup(bool isConfined,
+                             const QString& rootPath,
+                             const QUrl& url,
+                             const QVariantMap& metadata,
+                             const QMap<QString, QString>& headers) override;
+
+    Download* createDownloadForGroup(bool isConfined,
+                             const QString& rootPath,
+                             const QUrl& url,
+                             const QString& hash,
+                             QCryptographicHash::Algorithm algo,
+                             const QVariantMap& metadata,
+                             const QMap<QString, QString>& headers) override;
+
     QList<Download*> downloads();
 
  private:

=== modified file 'ubuntu-download-manager-tests/test_download.cpp'
--- ubuntu-download-manager-tests/test_download.cpp	2013-09-09 16:05:49 +0000
+++ ubuntu-download-manager-tests/test_download.cpp	2013-09-18 10:19:27 +0000
@@ -67,6 +67,8 @@
     setenv("XDG_DATA_HOME",
         _testDir.absolutePath().toStdString().c_str(), 1);
     _id = QUuid::createUuid();
+    _isConfined = false;
+    _rootPath = _testDir.absolutePath();
     _path = "random path to dbus";
     _url = QUrl("http://ubuntu.com");
     _algo = QCryptographicHash::Sha256;
@@ -111,8 +113,9 @@
     QFETCH(QString, path);
     QFETCH(QUrl, url);
 
-    SingleDownload* download = new SingleDownload(id, path, url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(id, path, _isConfined,
+        _rootPath, url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -159,7 +162,8 @@
     QFETCH(QString, hash);
     QFETCH(int, algo);
 
-    SingleDownload* download = new SingleDownload(id, path, url, hash,
+    SingleDownload* download = new SingleDownload(id, path, _isConfined,
+        _rootPath, url, hash,
         (QCryptographicHash::Algorithm)algo, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
@@ -192,7 +196,8 @@
 TestDownload::testPath() {
     // create an app download and assert that the returned data is correct
     QFETCH(QString, path);
-    SingleDownload* download = new SingleDownload(_id, path, _url, _metadata,
+    SingleDownload* download = new SingleDownload(_id, path, _isConfined,
+        _rootPath, _url, _metadata,
         _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
@@ -214,8 +219,9 @@
 TestDownload::testUrl() {
     // create an app download and assert that the returned data is correct
     QFETCH(QUrl, url);
-    SingleDownload* download = new SingleDownload(_id, _path, url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QCOMPARE(download->url(), url);
@@ -241,8 +247,9 @@
     QFETCH(qulonglong, total);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(progress(qulonglong, qulonglong)));
@@ -257,12 +264,12 @@
     reply->setData(fileData);
     emit reply->downloadProgress(received, total);
 
-    // assert that the total is set and tha the signals is emited
+    // assert that the total is set and that the signals is emited
     QCOMPARE(download->totalSize(), total);
     QCOMPARE(spy.count(), 1);
 
     QList<QVariant> arguments = spy.takeFirst();
-    // assert that the size isnot the received but the file size
+    // assert that the size is not the received but the file size
     QCOMPARE(arguments.at(0).toULongLong(), (qulonglong)fileData.size());
     QCOMPARE(arguments.at(1).toULongLong(), total);
     delete download;
@@ -287,8 +294,9 @@
     QFETCH(int, total);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(progress(qulonglong, qulonglong)));
@@ -321,8 +329,9 @@
     // assert that the total size is just set once
     // by emitting two signals with diff sizes
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(progress(qulonglong, qulonglong)));
@@ -344,8 +353,9 @@
 
 void
 TestDownload::testTotalSizeNoProgress() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QCOMPARE(0ULL, download->totalSize());
@@ -365,8 +375,9 @@
 void
 TestDownload::testSetThrottleNoReply() {
     QFETCH(qulonglong, speed);
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->setThrottle(speed);
@@ -388,8 +399,9 @@
     QFETCH(uint, speed);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->setThrottle(speed);
@@ -421,8 +433,9 @@
 TestDownload::testSetGSMDownloadSame() {
     QFETCH(bool, value);
 
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->allowGSMDownload(value);
@@ -446,8 +459,9 @@
     QFETCH(bool, oldValue);
     QFETCH(bool, newValue);
 
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->allowGSMDownload(oldValue);
@@ -491,8 +505,9 @@
     _networkInfo->setMode(mode.value<QNetworkInfo::NetworkMode>());
     _networkInfo->record();
 
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->allowGSMDownload(true);
@@ -539,8 +554,9 @@
     _networkInfo->setMode(mode.value<QNetworkInfo::NetworkMode>());
     _networkInfo->record();
 
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     download->allowGSMDownload(false);
@@ -552,8 +568,9 @@
 
 void
 TestDownload::testCancel() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(stateChanged()));
@@ -566,8 +583,9 @@
 
 void
 TestDownload::testPause() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(stateChanged()));
@@ -580,8 +598,9 @@
 
 void
 TestDownload::testResume() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(stateChanged()));
@@ -594,8 +613,9 @@
 
 void
 TestDownload::testStart() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(stateChanged()));
@@ -611,8 +631,9 @@
     // tell the fake nam to record so that we can access the reply
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -645,8 +666,9 @@
 void
 TestDownload::testCancelDownloadNotStarted() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -668,8 +690,9 @@
 void
 TestDownload::testPauseDownload() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -707,8 +730,9 @@
 
 void
 TestDownload::testPauseDownloadNotStarted() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -726,8 +750,9 @@
 
 void
 TestDownload::testResumeRunning() {
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -748,8 +773,9 @@
 void
 TestDownload::testResumeDownload() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(paused(bool result)));
@@ -788,8 +814,9 @@
 void
 TestDownload::testStartDownload() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -812,8 +839,9 @@
 void
 TestDownload::testStartDownloadAlreadyStarted() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download,
@@ -838,8 +866,9 @@
 void
 TestDownload::testOnSuccessNoHash() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        _metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(finished(QString)));
@@ -861,7 +890,8 @@
 void
 TestDownload::testOnSuccessHashError() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url,
         "imposible-hash-is-not-hex", _algo, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
@@ -924,7 +954,8 @@
     QFETCH(QString, hash);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, hash, _algo,
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, hash, _algo,
         _metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
@@ -963,8 +994,8 @@
 void
 TestDownload::testOnHttpError() {
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        _metadata, _headers,
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
@@ -1016,8 +1047,9 @@
 TestDownload::testSetRawHeadersStart() {
     QFETCH(StringMap, headers);
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        _metadata, headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -1072,8 +1104,9 @@
     // similar to the previous test but we want to ensure that range is not set
     QFETCH(StringMap, headers);
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        _metadata, headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -1123,8 +1156,9 @@
     QFETCH(StringMap, headers);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        _metadata, headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(paused(bool result)));
@@ -1203,8 +1237,9 @@
     QFETCH(StringMap, headers);
 
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url, _metadata,
-        headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, _metadata, headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(paused(bool result)));
@@ -1271,8 +1306,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -1334,8 +1370,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -1397,8 +1434,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
 
@@ -1439,8 +1477,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(finished(QString)));
@@ -1476,8 +1515,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(error(QString)));
@@ -1513,8 +1553,9 @@
 
     _processFactory->record();
     _reqFactory->record();
-    SingleDownload* download = new SingleDownload(_id, _path, _url,
-        metadata, _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    SingleDownload* download = new SingleDownload(_id, _path, _isConfined,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
     QSignalSpy spy(download , SIGNAL(error(QString)));
@@ -1540,3 +1581,37 @@
     process->emitFinished(1, QProcess::CrashExit);
     QCOMPARE(spy.count(), 1);
 }
+
+
+void
+TestDownload::testLocalPathConfined() {
+    // assert that the root path used is not the one in the metadata
+    QVariantMap metadata;
+    QString localPath = "/home/my/local/path";
+    metadata["local-path"] = localPath;
+
+    SingleDownload* download = new SingleDownload(_id, _path, true,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+        QSharedPointer<RequestFactory>(_reqFactory),
+        QSharedPointer<ProcessFactory>(_processFactory));
+
+    qDebug() << download->filePath();
+    QVERIFY(download->filePath() != localPath);
+}
+
+void
+TestDownload::testLocalPathNotConfined() {
+    QVariantMap metadata;
+    QString localPath = "/home/my/local/path";
+    metadata["local-path"] = localPath;
+
+    SingleDownload* download = new SingleDownload(_id, _path, false,
+        _rootPath, _url, metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+        QSharedPointer<RequestFactory>(_reqFactory),
+        QSharedPointer<ProcessFactory>(_processFactory));
+
+    qDebug() << download->filePath();
+    QCOMPARE(download->filePath(), localPath);
+}

=== modified file 'ubuntu-download-manager-tests/test_download.h'
--- ubuntu-download-manager-tests/test_download.h	2013-08-24 09:52:47 +0000
+++ ubuntu-download-manager-tests/test_download.h	2013-09-18 10:19:27 +0000
@@ -111,12 +111,18 @@
     void testProcessFinishedWithError();
     void testProcessFinishedCrash();
 
+    // local path generation tests
+    void testLocalPathConfined();
+    void testLocalPathNotConfined();
+
  private:
     bool removeDir(const QString& dirName);
 
  private:
     QDir _testDir;
     QUuid _id;
+    bool _isConfined;
+    QString _rootPath;
     QVariantMap _metadata;
     QMap<QString, QString> _headers;
     QString _path;

=== modified file 'ubuntu-download-manager-tests/test_download_factory.cpp'
--- ubuntu-download-manager-tests/test_download_factory.cpp	2013-09-10 15:27:32 +0000
+++ ubuntu-download-manager-tests/test_download_factory.cpp	2013-09-18 10:19:27 +0000
@@ -251,3 +251,37 @@
     QCOMPARE(download->downloadId(), id->value());
     QCOMPARE(download->path(), path->value());
 }
+
+void
+TestDownloadFactory::testCreateDownloadForGroup() {
+    _apparmor->record();
+    Download* download = _downFactory->createDownloadForGroup(true, "", QUrl(),
+        QVariantMap(), QMap<QString, QString>());
+
+    QList<MethodData> calledMethods = _apparmor->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    UuidWrapper* id = reinterpret_cast<UuidWrapper*>(
+        calledMethods[0].params().outParams()[0]);
+    StringWrapper* path = reinterpret_cast<StringWrapper*>(
+        calledMethods[0].params().outParams()[1]);
+
+    QCOMPARE(download->downloadId(), id->value());
+    QCOMPARE(download->path(), path->value());
+}
+
+void
+TestDownloadFactory::testCreateDownloadForGroupWithHash() {
+    _apparmor->record();
+    Download* download = _downFactory->createDownloadForGroup(true, "", QUrl(),
+        "", QCryptographicHash::Md5, QVariantMap(), QMap<QString, QString>());
+
+    QList<MethodData> calledMethods = _apparmor->calledMethods();
+    QCOMPARE(1, calledMethods.count());
+    UuidWrapper* id = reinterpret_cast<UuidWrapper*>(
+        calledMethods[0].params().outParams()[0]);
+    StringWrapper* path = reinterpret_cast<StringWrapper*>(
+        calledMethods[0].params().outParams()[1]);
+
+    QCOMPARE(download->downloadId(), id->value());
+    QCOMPARE(download->path(), path->value());
+}

=== modified file 'ubuntu-download-manager-tests/test_download_factory.h'
--- ubuntu-download-manager-tests/test_download_factory.h	2013-09-10 15:27:32 +0000
+++ ubuntu-download-manager-tests/test_download_factory.h	2013-09-18 10:19:27 +0000
@@ -48,6 +48,8 @@
     void testCreateDownloadWithHashAndNullUuid();
     void testCreateGroupDownloadWithValidUuid();
     void testCreateGroupDownloadWithNullUuid();
+    void testCreateDownloadForGroup();
+    void testCreateDownloadForGroupWithHash();
 
  private:
     FakeAppArmor* _apparmor;

=== modified file 'ubuntu-download-manager-tests/test_download_queue.cpp'
--- ubuntu-download-manager-tests/test_download_queue.cpp	2013-09-09 16:05:49 +0000
+++ ubuntu-download-manager-tests/test_download_queue.cpp	2013-09-18 10:19:27 +0000
@@ -26,15 +26,19 @@
 
 void
 TestDownloadQueue::init() {
+    _isConfined = true;
+    _rootPath = "/random/root/path";
     _networkInfo = new FakeSystemNetworkInfo();
     _reqFactory = new FakeRequestFactory();
     _processFactory = new FakeProcessFactory();
-    _first = new FakeDownload(QUuid::createUuid(), "first-path", QUrl(),
+    _first = new FakeDownload(QUuid::createUuid(), "first-path",
+        _isConfined, _rootPath, QUrl(),
         QVariantMap(), QMap<QString, QString>(),
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),
         QSharedPointer<ProcessFactory>(_processFactory));
-    _second = new FakeDownload(QUuid::createUuid(), "second-path", QUrl(),
+    _second = new FakeDownload(QUuid::createUuid(), "second-path",
+        _isConfined, _rootPath, QUrl(),
         QVariantMap(), QMap<QString, QString>(),
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<RequestFactory>(_reqFactory),

=== modified file 'ubuntu-download-manager-tests/test_download_queue.h'
--- ubuntu-download-manager-tests/test_download_queue.h	2013-09-01 17:34:24 +0000
+++ ubuntu-download-manager-tests/test_download_queue.h	2013-09-18 10:19:27 +0000
@@ -57,6 +57,8 @@
     void testDownloadErrorWithOtherReady();
 
  private:
+    bool _isConfined;
+    QString _rootPath;
     FakeSystemNetworkInfo* _networkInfo;
     FakeRequestFactory* _reqFactory;
     FakeProcessFactory* _processFactory;

=== modified file 'ubuntu-download-manager-tests/test_downloads_db.cpp'
--- ubuntu-download-manager-tests/test_downloads_db.cpp	2013-09-09 16:05:49 +0000
+++ ubuntu-download-manager-tests/test_downloads_db.cpp	2013-09-18 10:19:27 +0000
@@ -181,7 +181,7 @@
     QSharedPointer<ProcessFactory> processFactory =
         QSharedPointer<ProcessFactory>(new FakeProcessFactory());
 
-    FakeDownload* download = new FakeDownload(id, path, url, hash,
+    FakeDownload* download = new FakeDownload(id, path, false, "", url, hash,
         HashAlgorithm::getHashAlgo(hashAlgoString), metadata, headers,
         networkInfo, nam, processFactory);
 
@@ -279,7 +279,7 @@
     QSharedPointer<ProcessFactory> processFactory =
         QSharedPointer<ProcessFactory>(new FakeProcessFactory());
 
-    FakeDownload* download = new FakeDownload(id, path, url, hash,
+    FakeDownload* download = new FakeDownload(id, path, true, "", url, hash,
         HashAlgorithm::getHashAlgo(hashAlgoString), metadata, headers,
         networkInfo, nam, processFactory);
 
@@ -287,9 +287,9 @@
 
     // create a second download with same id but a diff path to test is update
     QString newPath = path + path;
-    FakeDownload* secondDownload = new FakeDownload(id, newPath, url, hash,
-        HashAlgorithm::getHashAlgo(hashAlgoString), metadata, headers,
-        networkInfo, nam, processFactory);
+    FakeDownload* secondDownload = new FakeDownload(id, newPath, true, "",
+        url, hash, HashAlgorithm::getHashAlgo(hashAlgoString), metadata,
+        headers, networkInfo, nam, processFactory);
 
     _db->storeSingleDownload(secondDownload);
 

=== modified file 'ubuntu-download-manager-tests/test_group_download.cpp'
--- ubuntu-download-manager-tests/test_group_download.cpp	2013-09-10 12:18:34 +0000
+++ ubuntu-download-manager-tests/test_group_download.cpp	2013-09-18 10:19:27 +0000
@@ -29,6 +29,8 @@
 TestGroupDownload::init() {
     _id = QUuid::createUuid();
     _path = "/group/dbus/path";
+    _isConfined = true;
+    _rootPath = "/random/dbus/path";
     _algo = QCryptographicHash::Md5;
     _isGSMDownloadAllowed = true;
     _networkInfo = new FakeSystemNetworkInfo();
@@ -62,9 +64,9 @@
 TestGroupDownload::testCancelNoDownloads() {
     QList<GroupDownloadStruct> downloads;
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloads, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
-        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined,
+        _rootPath, downloads, _algo, _isGSMDownloadAllowed, _metadata,
+        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
     group->cancelDownload();
@@ -78,8 +80,8 @@
     downloads.append(GroupDownloadStruct("http://ubuntu.com",
         "other_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloads, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloads, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -101,8 +103,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -135,8 +137,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -156,9 +158,9 @@
 TestGroupDownload::testPauseNoDownloads() {
     QList<GroupDownloadStruct> downloads;
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloads, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
-        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined,
+        _rootPath, downloads, _algo, _isGSMDownloadAllowed, _metadata,
+        _headers, QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
     group->pauseDownload();
@@ -172,8 +174,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
         "other_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -200,8 +202,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -234,8 +236,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -257,8 +259,8 @@
 TestGroupDownload::testResumeNoDownloads() {
     QList<GroupDownloadStruct> downloads;
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloads, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloads, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -277,8 +279,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -309,13 +311,14 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
 
     QList<Download*> downloads = _downloadFactory->downloads();
+    qDebug() << "Downloads" << downloads;
     reinterpret_cast<FakeDownload*>(downloads[0])->emitFinished(deleteFile);
     for (int index = 1; index < downloads.count(); index++) {
         downloads[index]->start();
@@ -344,8 +347,9 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined,
+        _rootPath, downloadsStruct, _algo, _isGSMDownloadAllowed,
+        _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -379,8 +383,9 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined,
+        _rootPath, downloadsStruct, _algo, _isGSMDownloadAllowed,
+        _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -399,7 +404,8 @@
 TestGroupDownload::testStartNoDownloads() {
     QList<GroupDownloadStruct> downloads;
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloads, _algo,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined,
+        _rootPath, downloads, _algo,
         _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
@@ -419,8 +425,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -447,8 +453,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -479,8 +485,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -513,8 +519,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -544,8 +550,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -576,8 +582,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -605,8 +611,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -635,8 +641,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -664,8 +670,8 @@
     downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
         "other_reddit_local_file", ""));
 
-    GroupDownload* group = new GroupDownload(_id, _path, downloadsStruct, _algo,
-        _isGSMDownloadAllowed, _metadata, _headers,
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
         QSharedPointer<SystemNetworkInfo>(_networkInfo),
         QSharedPointer<DownloadFactory>(_downloadFactory),
         QSharedPointer<FileManager>(_fileManager));
@@ -683,3 +689,75 @@
     QCOMPARE(2, calledMethods.count());
     QCOMPARE(spy.count(), 1);
 }
+
+void
+TestGroupDownload::testLocalPathSingleDownload() {
+    // assert that the local path of the download was set in the metadata
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct("http://one.ubunt.com",
+        "local_file", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "other_local_file", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    GroupDownload* group = new GroupDownload(_id, _path, _isConfined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+        QSharedPointer<DownloadFactory>(_downloadFactory),
+        QSharedPointer<FileManager>(_fileManager));
+
+    Q_UNUSED(group);
+
+    QList<Download*> downloads = _downloadFactory->downloads();
+
+    // assert that each metadata has the local file set
+    QVariantMap downMeta = downloads[0]->metadata();
+    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+        downloadsStruct[0].getLocalFile());
+
+    downMeta = downloads[1]->metadata();
+    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+        downloadsStruct[1].getLocalFile());
+
+    downMeta = downloads[2]->metadata();
+    QVERIFY(downMeta.contains(LOCAL_PATH_KEY));
+    QCOMPARE(downMeta[LOCAL_PATH_KEY].toString(),
+        downloadsStruct[2].getLocalFile());
+}
+
+void
+TestGroupDownload::testConfinedSingleDownload_data() {
+    QTest::addColumn<bool>("confined");
+
+    QTest::newRow("Confined") << true;
+    QTest::newRow("Unconfined") << false;
+}
+
+void
+TestGroupDownload::testConfinedSingleDownload() {
+    // assert that the created downloads are confined
+    QFETCH(bool, confined);
+
+    QList<GroupDownloadStruct> downloadsStruct;
+    downloadsStruct.append(GroupDownloadStruct("http://one.ubunt.com",
+        "local_file", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://ubuntu.com",
+        "other_local_file", ""));
+    downloadsStruct.append(GroupDownloadStruct("http://reddit.com",
+        "other_reddit_local_file", ""));
+
+    GroupDownload* group = new GroupDownload(_id, _path, confined, _rootPath,
+        downloadsStruct, _algo, _isGSMDownloadAllowed, _metadata, _headers,
+        QSharedPointer<SystemNetworkInfo>(_networkInfo),
+        QSharedPointer<DownloadFactory>(_downloadFactory),
+        QSharedPointer<FileManager>(_fileManager));
+
+    Q_UNUSED(group);
+
+    foreach(Download* download, _downloadFactory->downloads()) {
+        QCOMPARE(confined, download->isConfined());
+    }
+}

=== modified file 'ubuntu-download-manager-tests/test_group_download.h'
--- ubuntu-download-manager-tests/test_group_download.h	2013-09-10 12:18:34 +0000
+++ ubuntu-download-manager-tests/test_group_download.h	2013-09-18 10:19:27 +0000
@@ -64,10 +64,15 @@
     void testAllDownloadsFinished();
     void testSingleDownloadErrorNoFinished();
     void testSingleDownloadErrorWithFinished();
+    void testLocalPathSingleDownload();
+    void testConfinedSingleDownload_data();
+    void testConfinedSingleDownload();
 
  private:
     QUuid _id;
     QString _path;
+    bool _isConfined;
+    QString _rootPath;
     QCryptographicHash::Algorithm _algo;
     bool _isGSMDownloadAllowed;
     QVariantMap _metadata;