Merge lp:~mandel/ubuntu-download-manager/filter-all-per-app into lp:ubuntu-download-manager

[Manuel de la Peña]

Ensure that the getAllDownloads* methods do filter per app id if the application is confined.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:257
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/632/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/522
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/521

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

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/filter-all-per-app]

258. By Manuel de la Peña on 2014-04-29

Merged db-store-owner into filter-all-per-app.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:258
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/638/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-amd64-ci/528
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-trusty-armhf-ci/527

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

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/filter-all-per-app]

259. By Manuel de la Peña on 2014-04-29

Merged db-store-owner into filter-all-per-app.

260. By Manuel de la Peña on 2014-04-30

Merged db-store-owner into filter-all-per-app.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:260
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/645/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/4
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/4/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/filter-all-per-app]

261. By Manuel de la Peña on 2014-05-08

Merged db-store-owner into filter-all-per-app.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:261
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/653/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/12/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== modified file 'src/common/priv/CMakeLists.txt'
--- src/common/priv/CMakeLists.txt	2014-03-30 22:55:37 +0000
+++ src/common/priv/CMakeLists.txt	2014-05-08 15:17:33 +0000
@@ -11,6 +11,7 @@
 	ubuntu/transfers/system/application.cpp
         ubuntu/transfers/system/cryptographic_hash.cpp
 	ubuntu/transfers/system/dbus_proxy.cpp
+	ubuntu/transfers/system/dbus_proxy_factory.cpp
 	ubuntu/transfers/system/file_manager.cpp
 	ubuntu/transfers/system/filename_mutex.cpp
 	ubuntu/transfers/system/network_reply.cpp
@@ -36,9 +37,11 @@
 	ubuntu/transfers/system/application.h
         ubuntu/transfers/system/cryptographic_hash.h
 	ubuntu/transfers/system/dbus_proxy.h
+	ubuntu/transfers/system/dbus_proxy_factory.h
 	ubuntu/transfers/system/file_manager.h
 	ubuntu/transfers/system/filename_mutex.h
 	ubuntu/transfers/system/network_reply.h
+	ubuntu/transfers/system/pending_reply.h
 	ubuntu/transfers/system/process.h
 	ubuntu/transfers/system/process_factory.h
 	ubuntu/transfers/system/request_factory.h

=== modified file 'src/common/priv/ubuntu/transfers/system/apparmor.cpp'
--- src/common/priv/ubuntu/transfers/system/apparmor.cpp	2014-05-08 15:17:33 +0000
+++ src/common/priv/ubuntu/transfers/system/apparmor.cpp	2014-05-08 15:17:33 +0000
@@ -26,8 +26,10 @@
 #include <QRegExp>
 #include <QStandardPaths>
 #include <ubuntu/transfers/system/logger.h>
+#include "apparmor.h"
+#include "dbus_proxy_factory.h"
+#include "pending_reply.h"
 #include "uuid_utils.h"
-#include "apparmor.h"
 
 namespace Ubuntu {
 
@@ -39,16 +41,14 @@
 
 AppArmor::AppArmor(QObject* parent)
     : QObject(parent) {
-    _dbus = new DBusProxy("org.freedesktop.DBus", "/",
-        QDBusConnection::sessionBus(), this);
+    _dbus = DBusProxyFactory::instance()->createDBusProxy(this);
     _uuidFactory = new UuidFactory(this);
 }
 
 AppArmor::AppArmor(QSharedPointer<DBusConnection> connection,
                 QObject* parent)
     : QObject(parent) {
-    _dbus = new DBusProxy("org.freedesktop.DBus", "/",
-        connection->connection(), this);
+    _dbus = DBusProxyFactory::instance()->createDBusProxy(connection, this);
     _uuidFactory = new UuidFactory(this);
 }
 
@@ -74,6 +74,26 @@
     return details;
 }
 
+QString
+AppArmor::appId(QString caller) {
+    QScopedPointer<PendingReply<QString> > reply(
+        _dbus->GetConnectionAppArmorSecurityContext(caller));
+    // blocking but should be ok for now
+    reply->waitForFinished();
+    if (reply->isError()) {
+        return "";
+    }
+    return reply->value();
+}
+
+bool
+AppArmor::isConfined(QString appId) {
+    if (appId.isEmpty() || appId == UNCONFINED_ID) {
+        return false;
+    }
+    return true;
+}
+
 void
 AppArmor::getSecurityDetails(const QString& connName,
                              SecurityDetails* details) {
@@ -84,19 +104,19 @@
         return;
     }
 
-    QDBusPendingReply<QString> reply =
-        _dbus->GetConnectionAppArmorSecurityContext(connName);
+    QScopedPointer<PendingReply<QString> > reply (
+        _dbus->GetConnectionAppArmorSecurityContext(connName));
     // blocking but should be ok for now
-    reply.waitForFinished();
-    if (reply.isError()) {
-        LOG(ERROR) << reply.error(); 
+    reply->waitForFinished();
+    if (reply->isError()) {
+        LOG(ERROR) << reply->error();
         details->dbusPath = QString(BASE_ACCOUNT_URL) + "/" + details->id;
         details->localPath = getLocalPath("");
         details->isConfined = false;
         return;
     } else {
         // use the returned value
-        details->appId = reply.value();
+        details->appId = reply->value();
 
         if (details->appId.isEmpty() || details->appId == UNCONFINED_ID) {
             LOG(INFO) << "UNCONFINED APP";

=== modified file 'src/common/priv/ubuntu/transfers/system/apparmor.h'
--- src/common/priv/ubuntu/transfers/system/apparmor.h	2014-05-08 15:17:33 +0000
+++ src/common/priv/ubuntu/transfers/system/apparmor.h	2014-05-08 15:17:33 +0000
@@ -58,6 +58,10 @@
     virtual SecurityDetails* getSecurityDetails(const QString& connName);
     virtual SecurityDetails* getSecurityDetails(const QString& connName,
                                                 const QString& id);
+    virtual QString appId(QString caller);
+    virtual bool isConfined(QString appId);
+
+    static QString UNCONFINED_ID;
 
  private:
     void getSecurityDetails(const QString& connName,
@@ -66,7 +70,6 @@
 
  private:
     const char* BASE_ACCOUNT_URL = "/com/canonical/applications/download";
-    static QString UNCONFINED_ID;
 
     DBusProxy* _dbus;
     UuidFactory* _uuidFactory;

=== modified file 'src/common/priv/ubuntu/transfers/system/dbus_proxy.h'
--- src/common/priv/ubuntu/transfers/system/dbus_proxy.h	2014-03-07 15:07:43 +0000
+++ src/common/priv/ubuntu/transfers/system/dbus_proxy.h	2014-05-08 15:17:33 +0000
@@ -19,8 +19,10 @@
 #include <QtCore/QStringList>
 #include <QtCore/QVariant>
 #include <QtDBus/QtDBus>
+#include "pending_reply.h"
 
 typedef QMap<QString, QString> StringMap;
+using namespace Ubuntu::Transfers::System;
 
 /*
  * Proxy class for interface org.freedesktop.DBus
@@ -38,128 +40,132 @@
     ~DBusProxy();
 
 public Q_SLOTS: // METHODS
-    inline QDBusPendingReply<> AddMatch(const QString &in0)
+    virtual QDBusPendingReply<> AddMatch(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("AddMatch"), argumentList);
     }
 
-    inline QDBusPendingReply<QByteArray> GetAdtAuditSessionData(const QString &in0)
+    virtual QDBusPendingReply<QByteArray> GetAdtAuditSessionData(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("GetAdtAuditSessionData"), argumentList);
     }
 
-    inline QDBusPendingReply<QString> GetConnectionAppArmorSecurityContext(const QString &in0)
+    virtual PendingReply<QString>* GetConnectionAppArmorSecurityContext(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
-        return asyncCallWithArgumentList(QLatin1String("GetConnectionAppArmorSecurityContext"), argumentList);
+        QDBusPendingReply<QString> reply = asyncCallWithArgumentList(
+            QLatin1String("GetConnectionAppArmorSecurityContext"),
+            argumentList);
+        auto wrapper = new PendingReply<QString>(reply);
+        return wrapper;
     }
 
-    inline QDBusPendingReply<QByteArray> GetConnectionSELinuxSecurityContext(const QString &in0)
+    virtual QDBusPendingReply<QByteArray> GetConnectionSELinuxSecurityContext(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("GetConnectionSELinuxSecurityContext"), argumentList);
     }
 
-    inline QDBusPendingReply<uint> GetConnectionUnixProcessID(const QString &in0)
+    virtual QDBusPendingReply<uint> GetConnectionUnixProcessID(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("GetConnectionUnixProcessID"), argumentList);
     }
 
-    inline QDBusPendingReply<uint> GetConnectionUnixUser(const QString &in0)
+    virtual QDBusPendingReply<uint> GetConnectionUnixUser(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("GetConnectionUnixUser"), argumentList);
     }
 
-    inline QDBusPendingReply<QString> GetId()
+    virtual QDBusPendingReply<QString> GetId()
     {
         QList<QVariant> argumentList;
         return asyncCallWithArgumentList(QLatin1String("GetId"), argumentList);
     }
 
-    inline QDBusPendingReply<QString> GetNameOwner(const QString &in0)
+    virtual QDBusPendingReply<QString> GetNameOwner(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("GetNameOwner"), argumentList);
     }
 
-    inline QDBusPendingReply<QString> Hello()
+    virtual QDBusPendingReply<QString> Hello()
     {
         QList<QVariant> argumentList;
         return asyncCallWithArgumentList(QLatin1String("Hello"), argumentList);
     }
 
-    inline QDBusPendingReply<QStringList> ListActivatableNames()
+    virtual QDBusPendingReply<QStringList> ListActivatableNames()
     {
         QList<QVariant> argumentList;
         return asyncCallWithArgumentList(QLatin1String("ListActivatableNames"), argumentList);
     }
 
-    inline QDBusPendingReply<QStringList> ListNames()
+    virtual QDBusPendingReply<QStringList> ListNames()
     {
         QList<QVariant> argumentList;
         return asyncCallWithArgumentList(QLatin1String("ListNames"), argumentList);
     }
 
-    inline QDBusPendingReply<QStringList> ListQueuedOwners(const QString &in0)
+    virtual QDBusPendingReply<QStringList> ListQueuedOwners(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("ListQueuedOwners"), argumentList);
     }
 
-    inline QDBusPendingReply<bool> NameHasOwner(const QString &in0)
+    virtual QDBusPendingReply<bool> NameHasOwner(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("NameHasOwner"), argumentList);
     }
 
-    inline QDBusPendingReply<uint> ReleaseName(const QString &in0)
+    virtual QDBusPendingReply<uint> ReleaseName(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("ReleaseName"), argumentList);
     }
 
-    inline QDBusPendingReply<> ReloadConfig()
+    virtual QDBusPendingReply<> ReloadConfig()
     {
         QList<QVariant> argumentList;
         return asyncCallWithArgumentList(QLatin1String("ReloadConfig"), argumentList);
     }
 
-    inline QDBusPendingReply<> RemoveMatch(const QString &in0)
+    virtual QDBusPendingReply<> RemoveMatch(const QString &in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);
         return asyncCallWithArgumentList(QLatin1String("RemoveMatch"), argumentList);
     }
 
-    inline QDBusPendingReply<uint> RequestName(const QString &in0, uint in1)
+    virtual QDBusPendingReply<uint> RequestName(const QString &in0, uint in1)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
         return asyncCallWithArgumentList(QLatin1String("RequestName"), argumentList);
     }
 
-    inline QDBusPendingReply<uint> StartServiceByName(const QString &in0, uint in1)
+    virtual QDBusPendingReply<uint> StartServiceByName(const QString &in0, uint in1)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
         return asyncCallWithArgumentList(QLatin1String("StartServiceByName"), argumentList);
     }
 
-    inline QDBusPendingReply<> UpdateActivationEnvironment(StringMap in0)
+    virtual QDBusPendingReply<> UpdateActivationEnvironment(StringMap in0)
     {
         QList<QVariant> argumentList;
         argumentList << QVariant::fromValue(in0);

=== added file 'src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.cpp'
--- src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.cpp	1970-01-01 00:00:00 +0000
+++ src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.cpp	2014-05-08 15:17:33 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDBusConnection>
+#include "dbus_proxy_factory.h"
+
+namespace {
+    const QString DBUS_SERVICE_PATH = "org.freedesktop.DBus";
+    const QString DBUS_OBJECT_PATH = "/";
+}
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+namespace System {
+
+DBusProxyFactory* DBusProxyFactory::_instance = nullptr;
+QMutex DBusProxyFactory::_mutex;
+
+DBusProxyFactory::DBusProxyFactory(QObject* parent)
+    : QObject(parent) {
+}
+
+DBusProxy*
+DBusProxyFactory::createDBusProxy(QObject* parent) {
+    return new DBusProxy(DBUS_SERVICE_PATH, DBUS_OBJECT_PATH,
+        QDBusConnection::sessionBus(), parent);
+}
+
+DBusProxy*
+DBusProxyFactory::createDBusProxy(QSharedPointer<DBusConnection> connection,
+                                  QObject* parent) {
+    return new DBusProxy(DBUS_SERVICE_PATH, DBUS_OBJECT_PATH,
+        connection->connection(), parent);
+}
+
+DBusProxyFactory*
+DBusProxyFactory::instance() {
+    if(_instance == nullptr) {
+        _mutex.lock();
+        if(_instance == nullptr)
+            _instance = new DBusProxyFactory();
+        _mutex.unlock();
+    }
+    return _instance;
+}
+
+void
+DBusProxyFactory::setInstance(DBusProxyFactory* instance) {
+    _instance = instance;
+}
+
+void
+DBusProxyFactory::deleteInstance() {
+    if(_instance != nullptr) {
+        _mutex.lock();
+        if(_instance != nullptr) {
+            delete _instance;
+            _instance = nullptr;
+        }
+        _mutex.unlock();
+    }
+}
+
+}  // System
+
+}  // Transfers
+
+}  // Ubuntu

=== added file 'src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.h'
--- src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.h	1970-01-01 00:00:00 +0000
+++ src/common/priv/ubuntu/transfers/system/dbus_proxy_factory.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef DOWNLOADER_LIB_DBUS_PROXY_FACTORY_H
+#define DOWNLOADER_LIB_DBUS_PROXY_FACTORY_H
+
+#include <QSharedPointer>
+#include <QObject>
+#include <ubuntu/transfers/system/dbus_connection.h>
+#include "dbus_proxy.h"
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+namespace System {
+
+class DBusProxyFactory : public QObject {
+    Q_OBJECT
+
+ public:
+    virtual DBusProxy* createDBusProxy(QObject* parent=0);
+    virtual DBusProxy* createDBusProxy(
+            QSharedPointer<DBusConnection> connection, QObject* parent=0);
+
+    static DBusProxyFactory* instance();
+    // only used for testing purposes
+    static void setInstance(DBusProxyFactory* instance);
+    static void deleteInstance();
+
+ protected:
+    explicit DBusProxyFactory(QObject* parent=0);
+
+ private:
+    // used for the singleton
+    static DBusProxyFactory* _instance;
+    static QMutex _mutex;
+};
+
+}  // System
+
+}  // Transfers
+
+}  // Ubuntu
+
+#endif  // DOWNLOADER_LIB_REQUEST_FACTORY_H
+

=== added file 'src/common/priv/ubuntu/transfers/system/pending_reply.cpp'
=== added file 'src/common/priv/ubuntu/transfers/system/pending_reply.h'
--- src/common/priv/ubuntu/transfers/system/pending_reply.h	1970-01-01 00:00:00 +0000
+++ src/common/priv/ubuntu/transfers/system/pending_reply.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef DOWNLOADER_LIB_PENDING_REPLY_H
+#define DOWNLOADER_LIB_PENDING_REPLY_H
+
+#include <QDBusPendingReply>
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+namespace System {
+
+template <class T>
+class PendingReply {
+ public:
+    PendingReply() {
+    }
+
+    PendingReply(const QDBusPendingReply<T>& reply)
+        : _reply(reply) {
+    }
+
+    PendingReply(const PendingReply<T>& other)
+        : _reply(other._reply) {
+    }
+
+    // added to help mocking
+    virtual ~PendingReply() {
+    }
+
+    virtual T value () const {
+        return _reply.value();
+    }
+
+    virtual bool isError () const {
+        return _reply.isError();
+    }
+
+    virtual QDBusError error() const {
+        return _reply.error();
+    }
+
+    virtual void waitForFinished() {
+        _reply.waitForFinished();
+    }
+
+ private:
+    QDBusPendingReply<T> _reply;
+};
+
+}  // System
+
+}  // Transfers
+
+}  // Ubuntu
+
+#endif  // DOWNLOADER_LIB_PENDING_REPLY_H

=== modified file 'src/downloads/priv/ubuntu/downloads/manager.cpp'
--- src/downloads/priv/ubuntu/downloads/manager.cpp	2014-04-08 20:21:07 +0000
+++ src/downloads/priv/ubuntu/downloads/manager.cpp	2014-05-08 15:17:33 +0000
@@ -119,6 +119,19 @@
     emit sizeChanged(_downloadsQueue->size());
 }
 
+QString
+DownloadManager::getCaller() {
+    QString caller = "";
+
+    bool wasCalledFromDBus = calledFromDBus();
+    if (wasCalledFromDBus) {
+        caller = connection().interface()->serviceOwner(
+            message().service());
+        LOG(INFO) << "Owner is: " << caller;
+    }
+    return caller;
+}
+
 QDBusObjectPath
 DownloadManager::registerDownload(Download* download) {
     download->setThrottle(_throttle);
@@ -143,18 +156,10 @@
 
 QDBusObjectPath
 DownloadManager::createDownload(DownloadCreationFunc createDownloadFunc) {
-    QString owner = "";
-
-    bool wasCalledFromDBus = calledFromDBus();
-    if (wasCalledFromDBus) {
-        owner = connection().interface()->serviceOwner(
-            message().service());
-        LOG(INFO) << "Owner is: " << owner;
-    }
-
-    Download* download = createDownloadFunc(owner);
-
-    if (wasCalledFromDBus && !download->isValid()) {
+    auto owner = getCaller();
+    auto download = createDownloadFunc(owner);
+
+    if (calledFromDBus() && !download->isValid()) {
         sendErrorReply(QDBusError::InvalidArgs, download->lastError());
         // the result will be ignored thanks to the sendErrorReply
         return QDBusObjectPath();
@@ -257,15 +262,38 @@
 
 QList<QDBusObjectPath>
 DownloadManager::getAllDownloads() {
+    // filter per app id if owner is not "" and the app is confined else
+    // return all downloads
+    QScopedPointer<System::AppArmor> appArmor(new System::AppArmor());
+    auto owner = getCaller();
+    auto appId = appArmor->appId(owner);
     QList<QDBusObjectPath> paths;
-    foreach(const QString& path, _downloadsQueue->paths())
-        paths << QDBusObjectPath(path);
+    if (appArmor->isConfined(appId)) {
+        LOG(INFO) << "Returning downloads for api with id" << appId;
+        auto transfers = _downloadsQueue->transfers();
+        foreach(const QString& path, transfers.keys()) {
+            auto t = transfers[path];
+            if (t->transferAppId() == appId)
+                paths << QDBusObjectPath(path);
+        }
+    } else {
+        LOG(INFO) << "Returning all downloads for unconfined app";
+        foreach(const QString& path, _downloadsQueue->paths())
+            paths << QDBusObjectPath(path);
+    }
     return paths;
 }
 
 QList<QDBusObjectPath>
 DownloadManager::getAllDownloadsWithMetadata(const QString &name,
                                              const QString &value) {
+    // filter per app id if owner is not "" and the app is confined else
+    // return all downloads
+    QScopedPointer<System::AppArmor> appArmor(new System::AppArmor());
+    auto owner = getCaller();
+    auto appId = appArmor->appId(owner);
+    auto isConfined = appArmor->isConfined(appId);
+
     QList<QDBusObjectPath> paths;
     QHash<QString, Transfer*> downloads = _downloadsQueue->transfers();
     foreach(const QString& path, downloads.keys()) {
@@ -275,8 +303,11 @@
             if (metadata.contains(name)) {
                 QVariant data = metadata[name];
                 if (data.canConvert(QMetaType::QString)
-                        && data.toString() == value)
-                    paths << QDBusObjectPath(path);
+                        && data.toString() == value) {
+                    if (!isConfined || appId == down->transferAppId()) {
+                        paths << QDBusObjectPath(path);
+                    }
+                }
             }
         }
     }

=== modified file 'src/downloads/priv/ubuntu/downloads/manager.h'
--- src/downloads/priv/ubuntu/downloads/manager.h	2014-03-28 15:50:24 +0000
+++ src/downloads/priv/ubuntu/downloads/manager.h	2014-05-08 15:17:33 +0000
@@ -98,7 +98,6 @@
     typedef std::function<Download*(QString)> DownloadCreationFunc;
 
     void init();
-
     void loadPreviewsDownloads(QString path);
     void addDownload(Download* download);
     QDBusObjectPath createDownload(DownloadCreationFunc createDownloadFunc);
@@ -108,6 +107,7 @@
                                    const QVariantMap& metadata,
                                    StringMap headers);
     void onDownloadsChanged(QString);
+    QString getCaller();
 
  private:
     Application* _app = nullptr;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-03-27 12:54:03 +0000
+++ tests/CMakeLists.txt	2014-05-08 15:17:33 +0000
@@ -1,5 +1,6 @@
 set(DAEMON_TESTS
 	test_apn_request_factory
+	test_apparmor
         test_base_download
 	test_cancel_download_transition
         test_daemon
@@ -35,6 +36,8 @@
                 cryptographic_hash.h
 		database.h
                 dbus_connection.h
+		dbus_proxy.h
+		dbus_proxy_factory.h
 		download.h
                 factory.h
                 file_manager.h
@@ -42,6 +45,7 @@
 		manager.h
                 matchers.h
 		network_reply.h
+		pending_reply.h
                 process.h
                 process_factory.h
                 queue.h
@@ -114,6 +118,7 @@
 	${GLOG_LIBRARIES}
         ${Qt5Core_LIBRARIES}
         ${Qt5Sql_LIBRARIES}
+        ${Qt5DBus_LIBRARIES}
 	${Qt5Test_LIBRARIES}
         ${GMOCK_LIBRARY}
         ${GTEST_BOTH_LIBRARIES}

=== modified file 'tests/apparmor.h'
--- tests/apparmor.h	2014-03-12 16:18:31 +0000
+++ tests/apparmor.h	2014-05-08 15:17:33 +0000
@@ -37,6 +37,8 @@
         SecurityDetails*(const QString&));
     MOCK_METHOD2(getSecurityDetails,
         SecurityDetails*(const QString&, const QString&));
+    MOCK_METHOD1(appId, QString(QString caller));
+    MOCK_METHOD1(isConfined, bool(QString appId));
 };
 
 }  // Ubuntu

=== added file 'tests/dbus_proxy.h'
--- tests/dbus_proxy.h	1970-01-01 00:00:00 +0000
+++ tests/dbus_proxy.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FAKE_DBUS_PROXY_H
+#define FAKE_DBUS_PROXY_H
+
+#include <ubuntu/transfers/system/dbus_proxy.h>
+#include <gmock/gmock.h>
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+using namespace System;
+
+namespace Tests {
+
+class MockDBusProxy : public DBusProxy {
+ public:
+    MockDBusProxy() : DBusProxy("", "", QDBusConnection::sessionBus()) {}
+
+    MOCK_METHOD1(AddMatch, QDBusPendingReply<>(const QString&));
+    MOCK_METHOD1(GetAdtAuditSessionData,
+        QDBusPendingReply<QByteArray>(const QString&));
+    MOCK_METHOD1(GetConnectionAppArmorSecurityContext,
+        PendingReply<QString>*(const QString&));
+    MOCK_METHOD1(GetConnectionSELinuxSecurityContext,
+        QDBusPendingReply<QByteArray>(const QString&));
+    MOCK_METHOD1(GetConnectionUnixProcessID,
+        QDBusPendingReply<uint>(const QString&));
+    MOCK_METHOD1(GetConnectionUnixUser,
+        QDBusPendingReply<uint>(const QString&));
+    MOCK_METHOD0(GetId, QDBusPendingReply<QString>());
+    MOCK_METHOD1(GetNameOwner,
+        QDBusPendingReply<QString>(const QString&));
+    MOCK_METHOD0(Hello, QDBusPendingReply<QString>());
+    MOCK_METHOD0(ListActivatableNames, QDBusPendingReply<QStringList>());
+    MOCK_METHOD0(ListNames, QDBusPendingReply<QStringList>());
+    MOCK_METHOD1(ListQueuedOwners,
+        QDBusPendingReply<QStringList>(const QString&));
+    MOCK_METHOD1(NameHasOwner, QDBusPendingReply<bool>(const QString&));
+    MOCK_METHOD1(ReleaseName, QDBusPendingReply<uint>(const QString&));
+    MOCK_METHOD0(ReloadConfig, QDBusPendingReply<>());
+    MOCK_METHOD1(RemoveMatch, QDBusPendingReply<>(const QString&));
+    MOCK_METHOD2(RequestName,
+        QDBusPendingReply<uint>(const QString&, uint));
+    MOCK_METHOD2(StartServiceByName,
+        QDBusPendingReply<uint>(const QString&, uint));
+    MOCK_METHOD1(UpdateActivationEnvironment,
+        QDBusPendingReply<>(StringMap));
+};
+
+}  // Ubuntu
+
+}  // Transfers
+
+}  // Tests
+
+#endif  // FAKE_DBUS_PROXY_H

=== added file 'tests/dbus_proxy_factory.h'
--- tests/dbus_proxy_factory.h	1970-01-01 00:00:00 +0000
+++ tests/dbus_proxy_factory.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FAKE_DBUS_PROXY_FACTORY_H
+#define FAKE_DBUS_PROXY_FACTORY_H
+
+#include <ubuntu/transfers/system/dbus_proxy_factory.h>
+#include <gmock/gmock.h>
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+using namespace System;
+
+namespace Tests {
+
+class MockDBusProxyFactory : public DBusProxyFactory {
+ public:
+    MOCK_METHOD1(createDBusProxy, DBusProxy*(QObject*));
+    MOCK_METHOD2(createDBusProxy,
+        DBusProxy*(QSharedPointer<DBusConnection>, QObject*));
+};
+
+}  // Ubuntu
+
+}  // Transfers
+
+}  // Tests
+
+#endif  // FAKE_DBUS_PROXY_FACTORY_H

=== modified file 'tests/download.h'
--- tests/download.h	2014-05-08 15:17:33 +0000
+++ tests/download.h	2014-05-08 15:17:33 +0000
@@ -89,6 +89,7 @@
     MOCK_CONST_METHOD0(state, Transfer::State());
     MOCK_CONST_METHOD0(path, QString());
     MOCK_CONST_METHOD0(metadata, QVariantMap());
+    MOCK_CONST_METHOD0(transferAppId, QString());
     MOCK_METHOD1(allowGSMDownload, void(bool));
     MOCK_METHOD0(isGSMDownloadAllowed, bool());
 

=== added file 'tests/pending_reply.h'
--- tests/pending_reply.h	1970-01-01 00:00:00 +0000
+++ tests/pending_reply.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FAKE_PENDING_REPLY_H
+#define FAKE_PENDING_REPLY_H
+
+#include <ubuntu/transfers/system/pending_reply.h>
+#include <gmock/gmock.h>
+
+namespace Ubuntu {
+
+namespace Transfers {
+
+using namespace System;
+
+namespace Tests {
+
+template <class T>
+class MockPendingReply : public PendingReply<T> {
+ public:
+    MOCK_CONST_METHOD0_T(value, T());
+    MOCK_CONST_METHOD0_T(isError, bool());
+    MOCK_CONST_METHOD0_T(error, QDBusError());
+    MOCK_METHOD0_T(waitForFinished, void());
+};
+
+}  // Ubuntu
+
+}  // Transfers
+
+}  // Tests
+
+#endif  // FAKE_DBUS_PROXY_H
+

=== added file 'tests/test_apparmor.cpp'
--- tests/test_apparmor.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_apparmor.cpp	2014-05-08 15:17:33 +0000
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDBusMessage>
+#include <QScopedPointer>
+#include <ubuntu/transfers/system/apparmor.h>
+#include "dbus_proxy.h"
+#include "pending_reply.h"
+#include "test_apparmor.h"
+
+using ::testing::_;
+using ::testing::ByRef;
+using ::testing::Mock;
+using ::testing::Return;
+
+void
+TestAppArmor::init() {
+    BaseTestCase::init();
+    _dbusProxyFactory = new MockDBusProxyFactory();
+    DBusProxyFactory::setInstance(_dbusProxyFactory );
+}
+
+void
+TestAppArmor::cleanup() {
+    BaseTestCase::cleanup();
+    DBusProxyFactory::deleteInstance();
+}
+
+void
+TestAppArmor::testAppIdError() {
+    QString caller = "my app";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(caller))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(true));
+
+    QScopedPointer<AppArmor> appArmor(new AppArmor());
+
+    auto appId = appArmor->appId(caller);
+    QCOMPARE(QString(), appId);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
+}
+
+void
+TestAppArmor::testAppId() {
+    QString caller = "my app";
+    QString expectedAppId = "APPID";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(caller))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*reply, value())
+        .Times(1)
+        .WillOnce(Return(expectedAppId));
+
+    QScopedPointer<AppArmor> appArmor(new AppArmor());
+
+    auto appId = appArmor->appId(caller);
+    QCOMPARE(expectedAppId, appId);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
+}
+
+void
+TestAppArmor::testIsConfinedEmptyString() {
+    QString caller = "";
+    auto dbusProxy = new MockDBusProxy();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    QScopedPointer<AppArmor> appArmor(new AppArmor());
+    bool isConfined = appArmor->isConfined(caller);
+
+    QVERIFY(!isConfined);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
+}
+
+void
+TestAppArmor::testIsConfinedUnconfinedString() {
+    auto dbusProxy = new MockDBusProxy();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    QScopedPointer<AppArmor> appArmor(new AppArmor());
+    bool isConfined = appArmor->isConfined(AppArmor::UNCONFINED_ID);
+
+    QVERIFY(!isConfined);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
+}
+
+void
+TestAppArmor::testIsConfinedAppIdString() {
+    QString caller = "APPID";
+    auto dbusProxy = new MockDBusProxy();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    QScopedPointer<AppArmor> appArmor(new AppArmor());
+    bool isConfined = appArmor->isConfined(caller);
+
+    QVERIFY(isConfined);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
+}
+
+QTEST_MAIN(TestAppArmor)

=== added file 'tests/test_apparmor.h'
--- tests/test_apparmor.h	1970-01-01 00:00:00 +0000
+++ tests/test_apparmor.h	2014-05-08 15:17:33 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef TEST_APPARMOR_H
+#define TEST_APPARMOR_H
+
+#include <QObject>
+#include "base_testcase.h"
+#include "dbus_proxy_factory.h"
+
+using namespace Ubuntu::Transfers::Tests;
+using namespace Ubuntu::Transfers::System;
+
+class TestAppArmor : public BaseTestCase {
+    Q_OBJECT
+
+public:
+    explicit TestAppArmor(QObject *parent = 0)
+        : BaseTestCase("TestAppArmor", parent) { }
+
+ private slots:  // NOLINT(whitespace/indent)
+
+    void init() override;
+    void cleanup() override;
+
+    void testAppIdError();
+    void testAppId();
+    void testIsConfinedEmptyString();
+    void testIsConfinedUnconfinedString();
+    void testIsConfinedAppIdString();
+
+ private:
+    MockDBusProxyFactory* _dbusProxyFactory;
+};
+
+#endif // TEST_APN_REQUEST_FACTORY_H

=== modified file 'tests/test_download_manager.cpp'
--- tests/test_download_manager.cpp	2014-04-08 12:44:15 +0000
+++ tests/test_download_manager.cpp	2014-05-08 15:17:33 +0000
@@ -22,8 +22,10 @@
 #include <ubuntu/transfers/system/process_factory.h>
 #include <ubuntu/transfers/system/system_network_info.h>
 #include <gmock/gmock.h>
+#include "dbus_proxy.h"
 #include "download.h"
 #include "matchers.h"
+#include "pending_reply.h"
 #include "test_download_manager.h"
 
 using ::testing::_;
@@ -43,8 +45,9 @@
     _requestFactory = new MockRequestFactory();
     RequestFactory::setInstance(_requestFactory);
     _factory = new MockDownloadFactory();
-    qDebug() << "MOCK QUEUE" << _q;
     _man = new DownloadManager(_app, _conn, _factory, _q);
+    _dbusProxyFactory = new MockDBusProxyFactory();
+    DBusProxyFactory::setInstance(_dbusProxyFactory );
 }
 
 void
@@ -55,6 +58,7 @@
     RequestFactory::deleteInstance();
     ProcessFactory::deleteInstance();
     DownloadsDb::deleteInstance();
+    DBusProxyFactory::deleteInstance();
     delete _man;
     delete _conn;
     delete _app;
@@ -68,6 +72,7 @@
     QVERIFY(Mock::VerifyAndClearExpectations(_factory));
     QVERIFY(Mock::VerifyAndClearExpectations(_q));
     QVERIFY(Mock::VerifyAndClearExpectations(_requestFactory));
+    QVERIFY(Mock::VerifyAndClearExpectations(_dbusProxyFactory));
 }
 
 QCryptographicHash::Algorithm
@@ -277,71 +282,6 @@
 }
 
 void
-TestDownloadManager::testGetAllDownloads() {
-    // assert that we return the downloads from the q
-    QStringList expectedPaths;
-    expectedPaths.append("/first/path/object");
-    expectedPaths.append("/second/path/object");
-    expectedPaths.append("/third/path/object");
-
-    EXPECT_CALL(*_q, paths())
-        .Times(1)
-        .WillRepeatedly(Return(expectedPaths));
-
-    auto result = _man->getAllDownloads();
-    foreach(auto path, result) {
-        QVERIFY(expectedPaths.contains(path.path()));
-    }
-
-    verifyMocks();
-}
-
-void
-TestDownloadManager::testAllDownloadsWithMetadata() {
-    auto key = QString("filter");
-    auto value = QString("coconut");
-    auto validPath = QString("/valid/metadata/path");
-
-    QVariantMap filteredMetadata;
-    filteredMetadata[key] = value;
-    QVariantMap metadata;
-    QMap<QString, QString> headers;
-
-    QScopedPointer<MockDownload> first(new MockDownload("", "", "", "",
-        QUrl("http://one.ubunt.com"), metadata, headers));
-    QScopedPointer<MockDownload> second(new MockDownload("", "", "", "",
-        QUrl("http://ubuntu.com"), metadata, headers));
-    QScopedPointer<MockDownload> third(new MockDownload("", "", "", "",
-        QUrl("http://reddit.com"), metadata, headers));
-    QHash<QString, Transfer*> downs;
-    downs[validPath] = first.data();
-    downs["/second/object/path"] = second.data();
-    downs["/third/object/path"] = third.data();
-
-    EXPECT_CALL(*first.data(), metadata())
-        .Times(1)
-        .WillRepeatedly(Return(filteredMetadata));
-
-    EXPECT_CALL(*second.data(), metadata())
-        .Times(1)
-        .WillRepeatedly(Return(metadata));
-
-    EXPECT_CALL(*third.data(), metadata())
-        .Times(1)
-        .WillRepeatedly(Return(metadata));
-
-    EXPECT_CALL(*_q, transfers())
-        .Times(1)
-        .WillRepeatedly(Return(downs));
-
-    auto result = _man->getAllDownloadsWithMetadata(key, value);
-    QCOMPARE(1, result.count());
-    QCOMPARE(result[0].path(), validPath);
-
-    verifyMocks();
-}
-
-void
 TestDownloadManager::testSetThrottleNotDownloads_data() {
     QTest::addColumn<qulonglong>("speed");
 
@@ -510,4 +450,277 @@
     verifyMocks();
 }
 
+void
+TestDownloadManager::testGetAllDownloadsUnconfined() {
+    QString expectedAppId = "unconfined";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(_))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*reply, value())
+        .Times(1)
+        .WillOnce(Return(expectedAppId));
+
+    QStringList expectedPaths;
+    expectedPaths.append("/first/path/object");
+    expectedPaths.append("/second/path/object");
+    expectedPaths.append("/third/path/object");
+
+    EXPECT_CALL(*_q, paths())
+        .Times(1)
+        .WillRepeatedly(Return(expectedPaths));
+
+    auto result = _man->getAllDownloads();
+    QCOMPARE(3, result.count());
+    foreach(auto path, result) {
+        QVERIFY(expectedPaths.contains(path.path()));
+    }
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    verifyMocks();
+}
+
+void
+TestDownloadManager::testGetAllDownloadsConfined() {
+    QString expectedAppId = "APPID";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(_))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*reply, value())
+        .Times(1)
+        .WillOnce(Return(expectedAppId));
+
+    // create several downloads with diff app ids to check that we
+    // do getonly those with the correct app id
+    QVariantMap metadata;
+    QMap<QString, QString> headers;
+    QScopedPointer<MockDownload> first(new MockDownload("", "", "", "",
+        QUrl("http://one.ubunt.com"), metadata, headers));
+    QScopedPointer<MockDownload> second(new MockDownload("", "", "", "",
+        QUrl("http://ubuntu.com"), metadata, headers));
+    QScopedPointer<MockDownload> third(new MockDownload("", "", "", "",
+         QUrl("http://reddit.com"), metadata, headers));
+
+    QHash<QString, Transfer*> downs;
+    QStringList paths;
+    paths.append("/first/path/object");
+    paths.append("/second/path/object");
+    paths.append("/third/path/object");
+
+    downs[paths[0]] = first.data();
+    downs[paths[1]] = second.data();
+    downs[paths[2]] = third.data();
+
+    EXPECT_CALL(*first.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(expectedAppId));
+
+    EXPECT_CALL(*second.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(QString("SECONDAPP")));
+
+    EXPECT_CALL(*third.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(QString("LASTAPP")));
+
+    EXPECT_CALL(*_q, transfers())
+        .Times(1)
+        .WillRepeatedly(Return(downs));
+
+    auto result = _man->getAllDownloads();
+    QCOMPARE(1, result.count());
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    verifyMocks();
+}
+
+void
+TestDownloadManager::testAllDownloadsWithMetadataUnconfined() {
+    QString expectedAppId = "unconfined";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(_))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*reply, value())
+        .Times(1)
+        .WillOnce(Return(expectedAppId));
+
+    // create downloads to be used to filter
+    auto key = QString("filter");
+    auto value = QString("coconut");
+    auto validPath = QString("/valid/metadata/path");
+
+    QVariantMap filteredMetadata;
+    filteredMetadata[key] = value;
+    QVariantMap metadata;
+    QMap<QString, QString> headers;
+
+    QScopedPointer<MockDownload> first(new MockDownload("", "", "", "",
+        QUrl("http://one.ubunt.com"), metadata, headers));
+    QScopedPointer<MockDownload> second(new MockDownload("", "", "", "",
+        QUrl("http://ubuntu.com"), metadata, headers));
+    QScopedPointer<MockDownload> third(new MockDownload("", "", "", "",
+        QUrl("http://reddit.com"), metadata, headers));
+    QHash<QString, Transfer*> downs;
+    downs[validPath] = first.data();
+    downs["/second/object/path"] = second.data();
+    downs["/third/object/path"] = third.data();
+
+    EXPECT_CALL(*first.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(filteredMetadata));
+
+    EXPECT_CALL(*first.data(), transferAppId())
+        .Times(0);
+
+    EXPECT_CALL(*second.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(metadata));
+
+    EXPECT_CALL(*second.data(), transferAppId())
+        .Times(0);
+
+    EXPECT_CALL(*third.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(metadata));
+
+    EXPECT_CALL(*third.data(), transferAppId())
+        .Times(0);
+
+    EXPECT_CALL(*_q, transfers())
+        .Times(1)
+        .WillRepeatedly(Return(downs));
+
+    auto result = _man->getAllDownloadsWithMetadata(key, value);
+    QCOMPARE(1, result.count());
+    QCOMPARE(result[0].path(), validPath);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    verifyMocks();
+}
+
+void
+TestDownloadManager::testAllDownloadsWithMetadataConfined() {
+    QString expectedAppId = "APPID";
+    auto dbusProxy = new MockDBusProxy();
+    auto reply = new MockPendingReply<QString>();
+
+    EXPECT_CALL(*_dbusProxyFactory, createDBusProxy(_))
+        .Times(1)
+        .WillOnce(Return(dbusProxy));
+
+    EXPECT_CALL(*dbusProxy, GetConnectionAppArmorSecurityContext(_))
+        .Times(1)
+        .WillOnce(Return(reply));
+
+    EXPECT_CALL(*reply, waitForFinished())
+        .Times(1);
+
+    EXPECT_CALL(*reply, isError())
+        .Times(1)
+        .WillOnce(Return(false));
+
+    EXPECT_CALL(*reply, value())
+        .Times(1)
+        .WillOnce(Return(expectedAppId));
+
+    auto key = QString("filter");
+    auto value = QString("coconut");
+    auto validPath = QString("/valid/metadata/path");
+
+    QVariantMap filteredMetadata;
+    filteredMetadata[key] = value;
+    QVariantMap metadata;
+    QMap<QString, QString> headers;
+
+    QScopedPointer<MockDownload> first(new MockDownload("", "", "", "",
+        QUrl("http://one.ubunt.com"), metadata, headers));
+    QScopedPointer<MockDownload> second(new MockDownload("", "", "", "",
+        QUrl("http://ubuntu.com"), metadata, headers));
+    QScopedPointer<MockDownload> third(new MockDownload("", "", "", "",
+        QUrl("http://reddit.com"), metadata, headers));
+    QHash<QString, Transfer*> downs;
+    downs[validPath] = first.data();
+    downs["/second/object/path"] = second.data();
+    downs["/third/object/path"] = third.data();
+
+    EXPECT_CALL(*first.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(filteredMetadata));
+
+    EXPECT_CALL(*first.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(expectedAppId));
+
+    EXPECT_CALL(*second.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(filteredMetadata));
+
+    EXPECT_CALL(*second.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(QString("LEAPP")));
+
+    EXPECT_CALL(*third.data(), metadata())
+        .Times(1)
+        .WillRepeatedly(Return(filteredMetadata));
+
+    EXPECT_CALL(*third.data(), transferAppId())
+        .Times(1)
+        .WillRepeatedly(Return(QString("LEAPP")));
+
+    EXPECT_CALL(*_q, transfers())
+        .Times(1)
+        .WillRepeatedly(Return(downs));
+
+    auto result = _man->getAllDownloadsWithMetadata(key, value);
+    QCOMPARE(1, result.count());
+    QCOMPARE(result[0].path(), validPath);
+
+    QVERIFY(Mock::VerifyAndClearExpectations(dbusProxy));
+    verifyMocks();
+}
+
 QTEST_MAIN(TestDownloadManager)

=== modified file 'tests/test_download_manager.h'
--- tests/test_download_manager.h	2014-03-13 13:04:54 +0000
+++ tests/test_download_manager.h	2014-05-08 15:17:33 +0000
@@ -29,6 +29,7 @@
 #include "base_testcase.h"
 #include "database.h"
 #include "dbus_connection.h"
+#include "dbus_proxy_factory.h"
 #include "factory.h"
 #include "queue.h"
 #include "request_factory.h"
@@ -62,8 +63,6 @@
     // tests
     void testCreateDownload();
     void testCreateDownloadWithHash();
-    void testGetAllDownloads();
-    void testAllDownloadsWithMetadata();
     void testSetThrottleNotDownloads();
     void testSetThrottleWithDownloads();
     void testSizeChangedEmittedOnAddition();
@@ -72,6 +71,12 @@
     void testStoppable();
     void testNotStoppable();
 
+    // all downloads tests
+    void testGetAllDownloadsUnconfined();
+    void testGetAllDownloadsConfined();
+    void testAllDownloadsWithMetadataUnconfined();
+    void testAllDownloadsWithMetadataConfined();
+
  private:
     void verifyMocks();
     QCryptographicHash::Algorithm algoFromString(const QString& data);
@@ -84,6 +89,7 @@
     MockDownloadQueue* _q;
     DownloadManager* _man;
     MockRequestFactory* _requestFactory;
+    MockDBusProxyFactory* _dbusProxyFactory;
 };
 
 #endif  // TEST_DOWNLOADER_H