Merge lp:~lukas-kde/unity8/unity8DbusSessionService into lp:unity8

[Lukáš Tinkl]

Provide DBUS compatibility with various session services (suspend/hibernate, lock/unlock, screensaver, etc)

com.canonical.Unity currently lacks a lot of interfaces and methods in comparison with Unity 7 and other desktop environments.

Provide DBUS compatibility with various session services (suspend/hibernate, lock/unlock, screensaver, etc)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1814
http://jenkins.qa.ubuntu.com/job/unity8-ci/5835/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-wily-touch/129/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-amd64-ci/115/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-i386-ci/116/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/129/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5835/rebuild

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

You have bad tags

review: Needs Fixing

[Lukáš Tinkl (lukas-kde)]

According to the script, it looks clean:

ltinkl@ltinkl-Inspiron-7548:~/bzr/unity8/asyncDbusCalls$ ~/bin/strip-u8-tags.py ~/bzr/unity8/asyncDbusCalls/
/home/ltinkl/bzr/unity8/asyncDbusCalls/: clean

[Lukáš Tinkl (lukas-kde)]

Should be ok now

[Albert Astals Cid (aacid)]

Tags are good now.

review: Abstain

[lp:~lukas-kde/unity8/unity8DbusSessionService]

1815. By Lukáš Tinkl on 2015-06-29

[ Albert Astals Cid ]
* Refactor QmlTest.cmake module so that all tests can go through it.
  Also a bit of cleanup around tests.
* Support fallback images for dash card and preview widgets (LP:
  #1324142)
[ CI Train Bot ]
* New rebuild forced.
* Resync trunk.
[ Daniel d'Andrada ]
* Fix Shell tests
[ Josh Arenson ]
* Refactor greeter emulator to unlock the greeter via dbus
[ Lukáš Tinkl ]
* respect target window's devicePixelRatio in MouseTouchAdaptor
[ Michael Zanetti ]
* Refactor QmlTest.cmake module so that all tests can go through it.
  Also a bit of cleanup around tests.
[ Michał Sawicz ]
* Refactor QmlTest.cmake module so that all tests can go through it.
  Also a bit of cleanup around tests.
[ handsome_feng ]
* Forbid closing apps during the edge gesture. (LP: #1445572)
* Removed the horizonal rule on pin unlock screen. (LP: #1368798)
[ handsome_feng<email address hidden> ]
* Forbid closing apps during the edge gesture. (LP: #1445572)

1816. By Lukáš Tinkl on 2015-06-29

address minor issues in MP 262575

1817. By Lukáš Tinkl on 2015-06-29

fix failing username and real name tests

1818. By Lukáš Tinkl on 2015-06-30

fix CI

1819. By Lukáš Tinkl on 2015-06-30

remove commented out debug

1820. By Lukáš Tinkl on 2015-07-01

register the screensaver wrappers too

1821. By Lukáš Tinkl on 2015-07-21

merge and resolve conflict

Unmerged revisions

=== modified file 'plugins/AccountsService/AccountsService.cpp'
--- plugins/AccountsService/AccountsService.cpp	2015-04-17 16:39:32 +0000
+++ plugins/AccountsService/AccountsService.cpp	2015-06-19 11:26:12 +0000
@@ -23,10 +23,9 @@
 #include <QStringList>
 #include <QDebug>
 
-AccountsService::AccountsService(QObject* parent)
-  : QObject(parent),
+AccountsService::AccountsService(QObject* parent, const QString &user)
+    : QObject(parent),
     m_service(new AccountsServiceDBusAdaptor(this)),
-    m_user(""),
     m_demoEdges(false),
     m_enableLauncherWhileLocked(false),
     m_enableIndicatorsWhileLocked(false),
@@ -36,12 +35,10 @@
     m_hereEnabled(false),
     m_hereLicensePath() // null means not set yet
 {
-    connect(m_service, SIGNAL(propertiesChanged(const QString &, const QString &, const QStringList &)),
-            this, SLOT(propertiesChanged(const QString &, const QString &, const QStringList &)));
-    connect(m_service, SIGNAL(maybeChanged(const QString &)),
-            this, SLOT(maybeChanged(const QString &)));
+    connect(m_service, &AccountsServiceDBusAdaptor::propertiesChanged, this, &AccountsService::onPropertiesChanged);
+    connect(m_service, &AccountsServiceDBusAdaptor::maybeChanged, this, &AccountsService::onMaybeChanged);
 
-    setUser(qgetenv("USER"));
+    setUser(!user.isEmpty() ? user : QString::fromUtf8(qgetenv("USER")));
 }
 
 QString AccountsService::user() const
@@ -144,9 +141,9 @@
             this, [this](QDBusPendingCallWatcher* watcher) {
 
         QDBusPendingReply<QDBusVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'demo-edges' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
@@ -155,7 +152,6 @@
             m_demoEdges = demoEdges;
             Q_EMIT demoEdgesChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -173,19 +169,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'EnableLauncherWhileLocked' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto enableLauncherWhileLocked = reply.value().variant().toBool();
+        const bool enableLauncherWhileLocked = reply.value().toBool();
         if (m_enableLauncherWhileLocked != enableLauncherWhileLocked) {
             m_enableLauncherWhileLocked = enableLauncherWhileLocked;
             Q_EMIT enableLauncherWhileLockedChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -203,19 +198,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'EnableIndicatorsWhileLocked' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto enableIndicatorsWhileLocked = reply.value().variant().toBool();
+        const bool enableIndicatorsWhileLocked = reply.value().toBool();
         if (m_enableIndicatorsWhileLocked != enableIndicatorsWhileLocked) {
             m_enableIndicatorsWhileLocked = enableIndicatorsWhileLocked;
             Q_EMIT enableIndicatorsWhileLockedChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -233,19 +227,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'BackgroundFile' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto backgroundFile = reply.value().variant().toString();
+        const QString backgroundFile = reply.value().toString();
         if (m_backgroundFile != backgroundFile) {
             m_backgroundFile = backgroundFile;
             Q_EMIT backgroundFileChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -263,19 +256,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'StatsWelcomeScreen' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto statsWelcomeScreen = reply.value().variant().toBool();
+        const bool statsWelcomeScreen = reply.value().toBool();
         if (m_statsWelcomeScreen != statsWelcomeScreen) {
             m_statsWelcomeScreen = statsWelcomeScreen;
             Q_EMIT statsWelcomeScreenChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -293,19 +285,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'PasswordDisplayHint' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        PasswordDisplayHint passwordDisplayHint = (PasswordDisplayHint)reply.value().variant().toInt();
+        const PasswordDisplayHint passwordDisplayHint = (PasswordDisplayHint)reply.value().toInt();
         if (m_passwordDisplayHint != passwordDisplayHint) {
             m_passwordDisplayHint = passwordDisplayHint;
             Q_EMIT passwordDisplayHintChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -323,19 +314,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'FailedLogins' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        uint failedLogins = reply.value().variant().toUInt();
+        const uint failedLogins = reply.value().toUInt();
         if (m_failedLogins != failedLogins) {
             m_failedLogins = failedLogins;
             Q_EMIT failedLoginsChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -353,19 +343,18 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'LicenseAccepted' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto hereEnabled = reply.value().variant().toBool();
+        const bool hereEnabled = reply.value().toBool();
         if (m_hereEnabled != hereEnabled) {
             m_hereEnabled = hereEnabled;
             Q_EMIT hereEnabledChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -383,14 +372,14 @@
     connect(watcher, &QDBusPendingCallWatcher::finished,
             this, [this](QDBusPendingCallWatcher* watcher) {
 
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
         if (reply.isError()) {
             qWarning() << "Failed to get 'LicenseBasePath' property - " << reply.error().message();
-            watcher->deleteLater();
             return;
         }
 
-        auto hereLicensePath = reply.value().variant().toString();
+        QString hereLicensePath = reply.value().toString();
         if (hereLicensePath.isEmpty() || !QFile::exists(hereLicensePath))
             hereLicensePath = "";
 
@@ -398,7 +387,6 @@
             m_hereLicensePath = hereLicensePath;
             Q_EMIT hereLicensePathChanged();
         }
-        watcher->deleteLater();
     });
     if (!async) {
         watcher->waitForFinished();
@@ -421,7 +409,7 @@
     }
 }
 
-void AccountsService::propertiesChanged(const QString &user, const QString &interface, const QStringList &changed)
+void AccountsService::onPropertiesChanged(const QString &user, const QString &interface, const QStringList &changed)
 {
     if (m_user != user) {
         return;
@@ -459,7 +447,7 @@
     }
 }
 
-void AccountsService::maybeChanged(const QString &user)
+void AccountsService::onMaybeChanged(const QString &user)
 {
     if (m_user != user) {
         return;

=== modified file 'plugins/AccountsService/AccountsService.h'
--- plugins/AccountsService/AccountsService.h	2015-04-09 16:20:15 +0000
+++ plugins/AccountsService/AccountsService.h	2015-06-19 11:26:12 +0000
@@ -72,7 +72,8 @@
         Numeric,
     };
 
-    explicit AccountsService(QObject *parent = 0);
+    explicit AccountsService(QObject *parent = 0, const QString & user = QString());
+    ~AccountsService() = default;
 
     QString user() const;
     void setUser(const QString &user);
@@ -103,8 +104,8 @@
     void hereLicensePathChanged();
 
 private Q_SLOTS:
-    void propertiesChanged(const QString &user, const QString &interface, const QStringList &changed);
-    void maybeChanged(const QString &user);
+    void onPropertiesChanged(const QString &user, const QString &interface, const QStringList &changed);
+    void onMaybeChanged(const QString &user);
 
 private:
     void updateDemoEdges(bool async = true);

=== modified file 'plugins/AccountsService/AccountsServiceDBusAdaptor.cpp'
--- plugins/AccountsService/AccountsServiceDBusAdaptor.cpp	2015-04-10 10:22:18 +0000
+++ plugins/AccountsService/AccountsServiceDBusAdaptor.cpp	2015-06-19 11:26:12 +0000
@@ -21,35 +21,35 @@
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusVariant>
+#include <QDebug>
 
 AccountsServiceDBusAdaptor::AccountsServiceDBusAdaptor(QObject* parent)
   : QObject(parent),
     m_accountsManager(nullptr),
-    m_users(),
     m_ignoreNextChanged(false)
 {
     QDBusConnection connection = QDBusConnection::SM_BUSNAME();
     QDBusConnectionInterface *interface = connection.interface();
     interface->startService("org.freedesktop.Accounts");
     m_accountsManager = new QDBusInterface("org.freedesktop.Accounts",
-                                          "/org/freedesktop/Accounts",
-                                          "org.freedesktop.Accounts",
-                                          connection, this);
+                                           "/org/freedesktop/Accounts",
+                                           "org.freedesktop.Accounts",
+                                           connection, this);
 }
 
 QVariant AccountsServiceDBusAdaptor::getUserProperty(const QString &user, const QString &interface, const QString &property)
 {
     QDBusInterface *iface = getUserInterface(user);
     if (iface != nullptr && iface->isValid()) {
-        QDBusMessage answer = iface->call("Get", interface, property);
-        if (answer.type() == QDBusMessage::ReplyMessage) {
-            return answer.arguments()[0].value<QDBusVariant>().variant();
+        QDBusReply<QVariant> answer = iface->call("Get", interface, property);
+        if (answer.isValid()) {
+            return answer;
         }
     }
     return QVariant();
 }
 
-QDBusPendingReply<QDBusVariant> AccountsServiceDBusAdaptor::getUserPropertyAsync(const QString &user, const QString &interface, const QString &property)
+QDBusPendingReply<QVariant> AccountsServiceDBusAdaptor::getUserPropertyAsync(const QString &user, const QString &interface, const QString &property)
 {
     QDBusInterface *iface = getUserInterface(user);
     if (iface != nullptr && iface->isValid()) {
@@ -116,9 +116,9 @@
 {
     QDBusInterface *iface = m_users.value(user);
     if (iface == nullptr && m_accountsManager->isValid()) {
-        QDBusMessage answer = m_accountsManager->call("FindUserByName", user);
-        if (answer.type() == QDBusMessage::ReplyMessage) {
-            QString path = answer.arguments()[0].value<QDBusObjectPath>().path();
+        QDBusReply<QDBusObjectPath> answer = m_accountsManager->asyncCall("FindUserByName", user);
+        if (answer.isValid()) {
+            const QString path = answer.value().path();
 
             iface = new QDBusInterface("org.freedesktop.Accounts",
                                        path,
@@ -148,6 +148,8 @@
                 SLOT(propertiesChangedSlot(QString, QVariantMap, QStringList)));
 
             m_users.insert(user, iface);
+        } else {
+            qWarning() << "Couldn't get user interface" << answer.error().name() << answer.error().message();
         }
     }
     return iface;

=== modified file 'plugins/AccountsService/AccountsServiceDBusAdaptor.h'
--- plugins/AccountsService/AccountsServiceDBusAdaptor.h	2015-04-10 10:22:18 +0000
+++ plugins/AccountsService/AccountsServiceDBusAdaptor.h	2015-06-19 11:26:12 +0000
@@ -33,13 +33,14 @@
 
 public:
     explicit AccountsServiceDBusAdaptor(QObject *parent = 0);
+    ~AccountsServiceDBusAdaptor() = default;
 
     Q_INVOKABLE QVariant getUserProperty(const QString &user, const QString &interface, const QString &property);
-    Q_INVOKABLE QDBusPendingReply<QDBusVariant> getUserPropertyAsync(const QString &user, const QString &interface, const QString &property);
+    Q_INVOKABLE QDBusPendingReply<QVariant> getUserPropertyAsync(const QString &user, const QString &interface, const QString &property);
 
     template <typename T>
     inline T getUserProperty(const QString &user, const QString &interface, const QString &property) {
-        QVariant variant = getUserProperty(user, interface, property);
+        const QVariant variant = getUserProperty(user, interface, property);
         if (variant.isValid() && variant.canConvert<QDBusArgument>()) {
             return qdbus_cast<T>(variant.value<QDBusArgument>());
         }

=== modified file 'plugins/Lights/Lights.cpp'
--- plugins/Lights/Lights.cpp	2014-12-12 14:16:10 +0000
+++ plugins/Lights/Lights.cpp	2015-06-19 11:26:12 +0000
@@ -71,7 +71,7 @@
     if (m_color != color) {
         m_color = color;
         Q_EMIT colorChanged(m_color);
-        // FIXME: update the collor if the light is already on
+        // FIXME: update the color if the light is already on
     }
 }
 

=== modified file 'plugins/Powerd/Powerd.cpp'
--- plugins/Powerd/Powerd.cpp	2014-08-28 12:31:50 +0000
+++ plugins/Powerd/Powerd.cpp	2015-06-19 11:26:12 +0000
@@ -18,54 +18,49 @@
 
 #include "Powerd.h"
 #include <QDBusPendingCall>
-
-void autoBrightnessChanged(GSettings *settings, const gchar *key, QDBusInterface *unityScreen)
-{
-    bool value = g_settings_get_boolean(settings, key);
-    unityScreen->asyncCall("userAutobrightnessEnable", QVariant(value));
-}
-
-void activityTimeoutChanged(GSettings *settings, const gchar *key, QDBusInterface *unityScreen)
-{
-    int value = g_settings_get_uint(settings, key);
-    unityScreen->asyncCall("setInactivityTimeouts", QVariant(value), QVariant(-1));
-}
-
-void dimTimeoutChanged(GSettings *settings, const gchar *key, QDBusInterface *unityScreen)
-{
-    int value = g_settings_get_uint(settings, key);
-    unityScreen->asyncCall("setInactivityTimeouts", QVariant(-1), QVariant(value));
+#include <QDBusConnection>
+
+void autoBrightnessChanged(GSettings *settings, const gchar *key, Powerd * instance)
+{
+    const bool value = g_settings_get_boolean(settings, key);
+    instance->performAsyncCall("userAutobrightnessEnable", {value});
+}
+
+void activityTimeoutChanged(GSettings *settings, const gchar *key, Powerd * instance)
+{
+    const int value = g_settings_get_int(settings, key);
+    instance->performAsyncCall("setInactivityTimeouts", {value, -1});
+}
+
+void dimTimeoutChanged(GSettings *settings, const gchar *key, Powerd * instance)
+{
+    const int value = g_settings_get_int(settings, key);
+    instance->performAsyncCall("setInactivityTimeouts", {-1, value});
 }
 
 Powerd::Powerd(QObject* parent)
   : QObject(parent),
-    unityScreen(nullptr),
     cachedStatus(Status::On)
 {
-    unityScreen = new QDBusInterface("com.canonical.Unity.Screen",
-                                     "/com/canonical/Unity/Screen",
-                                     "com.canonical.Unity.Screen",
-                                     QDBusConnection::SM_BUSNAME(), this);
-
-    unityScreen->connection().connect("com.canonical.Unity.Screen",
-                                      "/com/canonical/Unity/Screen",
-                                      "com.canonical.Unity.Screen",
-                                      "DisplayPowerStateChange",
-                                      this,
-                                      SLOT(handleDisplayPowerStateChange(int, int)));
+    QDBusConnection::SM_BUSNAME().connect("com.canonical.Unity.Screen",
+                                          "/com/canonical/Unity/Screen",
+                                          "com.canonical.Unity.Screen",
+                                          "DisplayPowerStateChange",
+                                          this,
+                                          SLOT(handleDisplayPowerStateChange(int, int)));
 
     systemSettings = g_settings_new("com.ubuntu.touch.system");
-    g_signal_connect(systemSettings, "changed::auto-brightness", G_CALLBACK(autoBrightnessChanged), unityScreen);
-    g_signal_connect(systemSettings, "changed::activity-timeout", G_CALLBACK(activityTimeoutChanged), unityScreen);
-    g_signal_connect(systemSettings, "changed::dim-timeout", G_CALLBACK(dimTimeoutChanged), unityScreen);
-    autoBrightnessChanged(systemSettings, "auto-brightness", unityScreen);
-    activityTimeoutChanged(systemSettings, "activity-timeout", unityScreen);
-    dimTimeoutChanged(systemSettings, "dim-timeout", unityScreen);
+    g_signal_connect(systemSettings, "changed::auto-brightness", G_CALLBACK(autoBrightnessChanged), this);
+    g_signal_connect(systemSettings, "changed::activity-timeout", G_CALLBACK(activityTimeoutChanged), this);
+    g_signal_connect(systemSettings, "changed::dim-timeout", G_CALLBACK(dimTimeoutChanged), this);
+    autoBrightnessChanged(systemSettings, "auto-brightness", this);
+    activityTimeoutChanged(systemSettings, "activity-timeout", this);
+    dimTimeoutChanged(systemSettings, "dim-timeout", this);
 }
 
 Powerd::~Powerd()
 {
-    g_signal_handlers_disconnect_by_data(systemSettings, unityScreen);
+    g_signal_handlers_disconnect_by_data(systemSettings, this);
     g_object_unref(systemSettings);
 }
 
@@ -81,3 +76,13 @@
         Q_EMIT statusChanged((DisplayStateChangeReason)reason);
     }
 }
+
+void Powerd::performAsyncCall(const QString &method, const QVariantList &args)
+{
+    QDBusMessage msg = QDBusMessage::createMethodCall("com.canonical.Unity.Screen",
+                                                      "/com/canonical/Unity/Screen",
+                                                      "com.canonical.Unity.Screen",
+                                                      method);
+    msg.setArguments(args);
+    QDBusConnection::SM_BUSNAME().asyncCall(msg);
+}

=== modified file 'plugins/Powerd/Powerd.h'
--- plugins/Powerd/Powerd.h	2014-07-23 21:18:57 +0000
+++ plugins/Powerd/Powerd.h	2015-06-19 11:26:12 +0000
@@ -21,8 +21,7 @@
 #define UNITY_POWERD_H
 
 #include <gio/gio.h>
-#include <QtCore/QObject>
-#include <QtDBus/QDBusInterface>
+#include <QObject>
 
 class Powerd: public QObject
 {
@@ -30,6 +29,7 @@
     Q_ENUMS(Status)
     Q_ENUMS(DisplayStateChangeReason)
     Q_PROPERTY(Status status READ status NOTIFY statusChanged)
+    Q_DISABLE_COPY(Powerd)
 
 public:
     enum DisplayStateChangeReason {
@@ -49,6 +49,8 @@
 
     Status status() const;
 
+    void performAsyncCall(const QString &method, const QVariantList &args);
+
 Q_SIGNALS:
     void statusChanged(DisplayStateChangeReason reason);
 
@@ -56,7 +58,6 @@
     void handleDisplayPowerStateChange(int status, int reason);
 
 private:
-    QDBusInterface *unityScreen;
     GSettings *systemSettings;
     Status cachedStatus;
 };

=== modified file 'plugins/Ubuntu/SystemImage/SystemImage.cpp'
--- plugins/Ubuntu/SystemImage/SystemImage.cpp	2014-07-30 11:08:29 +0000
+++ plugins/Ubuntu/SystemImage/SystemImage.cpp	2015-06-19 11:26:12 +0000
@@ -16,19 +16,18 @@
 
 #include "SystemImage.h"
 #include <QDBusConnection>
-#include <QDBusInterface>
+#include <QDBusPendingCall>
 
 SystemImage::SystemImage(QObject *parent)
-    : QObject(parent),
-      m_interface(new QDBusInterface("com.canonical.SystemImage",
-                                     "/Service",
-                                     "com.canonical.SystemImage",
-                                     QDBusConnection::systemBus(),
-                                     this))
+    : QObject(parent)
 {
 }
 
 void SystemImage::factoryReset()
 {
-    m_interface->call("FactoryReset");
+    const QDBusMessage msg = QDBusMessage::createMethodCall("com.canonical.SystemImage",
+                                                            "/Service",
+                                                            "com.canonical.SystemImage",
+                                                            "FactoryReset");
+    QDBusConnection::systemBus().asyncCall(msg);
 }

=== modified file 'plugins/Ubuntu/SystemImage/SystemImage.h'
--- plugins/Ubuntu/SystemImage/SystemImage.h	2014-07-30 11:08:29 +0000
+++ plugins/Ubuntu/SystemImage/SystemImage.h	2015-06-19 11:26:12 +0000
@@ -19,8 +19,6 @@
 
 #include <QObject>
 
-class QDBusInterface;
-
 class SystemImage : public QObject
 {
     Q_OBJECT
@@ -28,11 +26,9 @@
 
 public:
     explicit SystemImage(QObject *parent = 0);
+    ~SystemImage() = default;
 
     Q_INVOKABLE void factoryReset();
-
-private:
-    QDBusInterface *m_interface;
 };
 
 #endif // SYSTEMIMAGE_H

=== modified file 'plugins/Unity/Connectivity/Connectivity.cpp'
--- plugins/Unity/Connectivity/Connectivity.cpp	2014-08-20 17:14:55 +0000
+++ plugins/Unity/Connectivity/Connectivity.cpp	2015-06-19 11:26:12 +0000
@@ -16,7 +16,6 @@
 
 #include "Connectivity.h"
 #include <QDBusConnection>
-#include <QDBusInterface>
 #include <QDBusPendingCall>
 
 Connectivity::Connectivity(QObject *parent)
@@ -26,8 +25,9 @@
 
 void Connectivity::unlockAllModems()
 {
-    QDBusInterface iface("com.ubuntu.connectivity1",
-                         "/com/ubuntu/connectivity1/Private",
-                         "com.ubuntu.connectivity1.Private");
-    iface.asyncCall("UnlockAllModems");
+    const QDBusMessage msg = QDBusMessage::createMethodCall("com.ubuntu.connectivity1",
+                                                            "/com/ubuntu/connectivity1/Private",
+                                                            "com.ubuntu.connectivity1.Private",
+                                                            "UnlockAllModems");
+    QDBusConnection::sessionBus().asyncCall(msg);
 }

=== modified file 'plugins/Unity/Connectivity/Connectivity.h'
--- plugins/Unity/Connectivity/Connectivity.h	2014-08-20 17:14:55 +0000
+++ plugins/Unity/Connectivity/Connectivity.h	2015-06-19 11:26:12 +0000
@@ -26,6 +26,7 @@
 
 public:
     explicit Connectivity(QObject *parent = 0);
+    ~Connectivity() = default;
 
     Q_INVOKABLE void unlockAllModems();
 };

=== modified file 'plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h'
--- plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h	2014-10-30 21:43:18 +0000
+++ plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h	2015-06-19 11:26:12 +0000
@@ -36,4 +36,4 @@
 
 };
 
-#endif // DBUSUNITYSESSIONSERVICE_H
+#endif // DBUSDASHCOMMUNICATORSERVICE_H

=== modified file 'plugins/Unity/DashCommunicator/plugin.cpp'
--- plugins/Unity/DashCommunicator/plugin.cpp	2014-07-24 16:02:27 +0000
+++ plugins/Unity/DashCommunicator/plugin.cpp	2015-06-19 11:26:12 +0000
@@ -25,6 +25,7 @@
 
 void DashCommunicatorPlugin::registerTypes(const char *uri)
 {
+    // @uri Unity.DashCommunicator
     Q_ASSERT(uri == QStringLiteral("Unity.DashCommunicator"));
     qmlRegisterType<DashCommunicatorService>(uri, 0, 1, "DashCommunicatorService");
     qmlRegisterType<DashCommunicator>(uri, 0, 1, "DashCommunicator");

=== modified file 'plugins/Unity/Launcher/dbusinterface.cpp'
--- plugins/Unity/Launcher/dbusinterface.cpp	2014-11-04 12:53:23 +0000
+++ plugins/Unity/Launcher/dbusinterface.cpp	2015-06-19 11:26:12 +0000
@@ -32,10 +32,6 @@
 {
 }
 
-DBusInterface::~DBusInterface()
-{
-}
-
 QString DBusInterface::introspect(const QString &path) const
 {
     /* This case we should just list the nodes */

=== modified file 'plugins/Unity/Launcher/dbusinterface.h'
--- plugins/Unity/Launcher/dbusinterface.h	2014-10-09 15:00:32 +0000
+++ plugins/Unity/Launcher/dbusinterface.h	2015-06-19 11:26:12 +0000
@@ -27,7 +27,7 @@
     Q_OBJECT
 public:
     DBusInterface(LauncherModel *parent);
-    ~DBusInterface();
+    ~DBusInterface() = default;
 
     // QDBusVirtualObject implementaition
     QString introspect (const QString &path) const override;

=== modified file 'plugins/Unity/Session/CMakeLists.txt'
--- plugins/Unity/Session/CMakeLists.txt	2015-02-03 12:17:50 +0000
+++ plugins/Unity/Session/CMakeLists.txt	2015-06-19 11:26:12 +0000
@@ -2,6 +2,7 @@
 
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_BINARY_DIR}
     ${GIO_INCLUDE_DIRS}
     ${libunity8-private_SOURCE_DIR}
 )

=== modified file 'plugins/Unity/Session/dbusunitysessionservice.cpp'
--- plugins/Unity/Session/dbusunitysessionservice.cpp	2015-03-02 12:11:03 +0000
+++ plugins/Unity/Session/dbusunitysessionservice.cpp	2015-06-19 11:26:12 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014, 2015 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License version 3, as published by
@@ -12,122 +12,462 @@
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Lukáš Tinkl <[e-mail]>
+ *          Christopher Townsend <[e-mail]>
+ *          Ying-Chun Liu (PaulLiu) <[e-mail]>
  */
 
 // local
 #include "dbusunitysessionservice.h"
 
+// system
+#include <sys/types.h>
+#include <unistd.h>
+#include <pwd.h>
+
 // Qt
-#include <QDBusConnection>
-#include <QDBusInterface>
+#include <QDebug>
+#include <QDBusPendingCall>
+#include <QDBusReply>
+#include <QElapsedTimer>
+#include <QDateTime>
+
+#define LOGIN1_SERVICE QStringLiteral("org.freedesktop.login1")
+#define LOGIN1_PATH QStringLiteral("/org/freedesktop/login1")
+#define LOGIN1_IFACE QStringLiteral("org.freedesktop.login1.Manager")
+#define LOGIN1_SESSION_IFACE QStringLiteral("org.freedesktop.login1.Session")
+
+#define ACTIVE_KEY QStringLiteral("Active")
+#define IDLE_SINCE_KEY QStringLiteral("IdleSinceHint")
+
+class DBusUnitySessionServicePrivate: public QObject
+{
+    Q_OBJECT
+public:
+    QString logindSessionPath;
+    bool isSessionActive = true;
+    QElapsedTimer screensaverActiveTimer;
+
+    DBusUnitySessionServicePrivate(): QObject() {
+        init();
+        checkActive();
+    }
+
+    void init()
+    {
+        // get our logind session path
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE,
+                                                          LOGIN1_PATH,
+                                                          LOGIN1_IFACE,
+                                                          "GetSessionByPID");
+        msg << (quint32) getpid();
+
+        QDBusReply<QDBusObjectPath> reply = QDBusConnection::systemBus().asyncCall(msg);
+        if (reply.isValid()) {
+            logindSessionPath = reply.value().path();
+            //qDebug() << "session path" << logindSessionPath;
+
+            // start watching the Active property
+            QDBusConnection::systemBus().connect(LOGIN1_SERVICE, logindSessionPath, "org.freedesktop.DBus.Properties", "PropertiesChanged",
+                                                 this, SLOT(onPropertiesChanged(QString,QVariantMap,QStringList)));
+        } else {
+            qWarning() << "Failed to get logind session path" << reply.error().message();
+        }
+    }
+
+    bool checkLogin1Call(const QString &method) const
+    {
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE, LOGIN1_PATH, LOGIN1_IFACE, method);
+        QDBusReply<QString> reply = QDBusConnection::systemBus().asyncCall(msg);
+        return reply.isValid() && (reply == QStringLiteral("yes") || reply == QStringLiteral("challenge"));
+    }
+
+    void makeLogin1Call(const QString &method, const QVariantList &args)
+    {
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE,
+                                                          LOGIN1_PATH,
+                                                          LOGIN1_IFACE,
+                                                          method);
+        msg.setArguments(args);
+        QDBusConnection::systemBus().asyncCall(msg);
+    }
+
+    void checkActive()
+    {
+        if (logindSessionPath.isEmpty()) {
+            qWarning() << "Invalid session path";
+            return;
+        }
+
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE,
+                                                          logindSessionPath,
+                                                          "org.freedesktop.DBus.Properties",
+                                                          "Get");
+        msg << LOGIN1_SESSION_IFACE;
+        msg << ACTIVE_KEY;
+
+        QDBusReply<QVariant> reply = QDBusConnection::systemBus().asyncCall(msg);
+        if (reply.isValid()) {
+            isSessionActive = reply.value().toBool();
+            qDebug() << "Session" << logindSessionPath << "is active:" << isSessionActive;
+        } else {
+            qWarning() << "Failed to get Active property" << reply.error().message();
+        }
+    }
+
+    quint32 screensaverActiveTime() const
+    {
+        if (!isSessionActive && screensaverActiveTimer.isValid()) {
+            return screensaverActiveTimer.elapsed() / 1000;
+        }
+
+        return 0;
+    }
+
+    quint64 idleSinceUSecTimestamp() const
+    {
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE,
+                                                          logindSessionPath,
+                                                          "org.freedesktop.DBus.Properties",
+                                                          "Get");
+        msg << LOGIN1_SESSION_IFACE;
+        msg << IDLE_SINCE_KEY;
+
+        QDBusReply<QVariant> reply = QDBusConnection::systemBus().asyncCall(msg);
+        if (reply.isValid()) {
+            return reply.value().value<quint64>();
+        } else {
+            qWarning() << "Failed to get IdleSinceHint property" << reply.error().message();
+        }
+
+        return 0;
+    }
+
+    void setIdleHint(bool idle)
+    {
+        QDBusMessage msg = QDBusMessage::createMethodCall(LOGIN1_SERVICE,
+                                                          logindSessionPath,
+                                                          LOGIN1_SESSION_IFACE,
+                                                          "SetIdleHint");
+        msg << idle;
+        QDBusConnection::systemBus().asyncCall(msg);
+    }
+
+private Q_SLOTS:
+    void onPropertiesChanged(const QString &iface, const QVariantMap &changedProps, const QStringList &invalidatedProps)
+    {
+        Q_UNUSED(iface)
+
+        if (changedProps.contains(ACTIVE_KEY) || invalidatedProps.contains(ACTIVE_KEY)) {
+            if (changedProps.value(ACTIVE_KEY).isValid()) {
+                isSessionActive = changedProps.value(ACTIVE_KEY).toBool();
+            } else {
+                checkActive();
+            }
+
+            Q_EMIT screensaverActiveChanged(!isSessionActive);
+
+            if (isSessionActive) {
+                screensaverActiveTimer.invalidate();
+                setIdleHint(false);
+            } else {
+                screensaverActiveTimer.start();
+                setIdleHint(true);
+            }
+        }
+    }
+
+Q_SIGNALS:
+    void screensaverActiveChanged(bool active);
+};
+
+Q_GLOBAL_STATIC(DBusUnitySessionServicePrivate, d)
 
 DBusUnitySessionService::DBusUnitySessionService()
     : UnityDBusObject("/com/canonical/Unity/Session", "com.canonical.Unity")
 {
-}
-
-DBusUnitySessionService::~DBusUnitySessionService()
-{
+    if (!d->logindSessionPath.isEmpty()) {
+        // connect our Lock() slot to the logind's session Lock() signal
+        QDBusConnection::systemBus().connect(LOGIN1_SERVICE, d->logindSessionPath, LOGIN1_SESSION_IFACE, "Lock", this, SLOT(Lock()));
+        // ... and our Unlocked() signal to the logind's session Unlock() signal
+        // (lightdm handles the unlocking by calling logind's Unlock method which in turn emits this signal we connect to)
+        QDBusConnection::systemBus().connect(LOGIN1_SERVICE, d->logindSessionPath, LOGIN1_SESSION_IFACE, "Unlock", this, SIGNAL(Unlocked()));
+    } else {
+        qWarning() << "Failed to connect to logind's session Lock/Unlock signals";
+    }
 }
 
 void DBusUnitySessionService::Logout()
 {
-  Q_EMIT logoutReady();
+    // TODO ask the apps to quit and then emit the signal
+    Q_EMIT LogoutReady();
 }
 
 void DBusUnitySessionService::EndSession()
 {
-  QDBusConnection connection = QDBusConnection::sessionBus();
-  QDBusInterface iface1 ("com.ubuntu.Upstart",
-                         "/com/ubuntu/Upstart",
-                         "com.ubuntu.Upstart0_6",
-                         connection);
-
-  iface1.call("EndSession");
+    const QDBusMessage msg = QDBusMessage::createMethodCall("com.ubuntu.Upstart",
+                                                            "/com/ubuntu/Upstart",
+                                                            "com.ubuntu.Upstart0_6",
+                                                            "EndSession");
+    QDBusConnection::sessionBus().asyncCall(msg);
+}
+
+bool DBusUnitySessionService::CanHibernate() const
+{
+    return d->checkLogin1Call("CanHibernate");
+}
+
+bool DBusUnitySessionService::CanSuspend() const
+{
+    return d->checkLogin1Call("CanSuspend");
+}
+
+bool DBusUnitySessionService::CanHybridSleep() const
+{
+    return d->checkLogin1Call("CanHybridSleep");
+}
+
+bool DBusUnitySessionService::CanReboot() const
+{
+    return d->checkLogin1Call("CanReboot");
+}
+
+bool DBusUnitySessionService::CanShutdown() const
+{
+    return d->checkLogin1Call("CanPowerOff");
+}
+
+bool DBusUnitySessionService::CanLock() const
+{
+    return true; // FIXME
+}
+
+QString DBusUnitySessionService::UserName() const
+{
+    struct passwd *p = getpwuid(getuid());
+    if (p) {
+        return QString::fromUtf8(p->pw_name);
+    }
+
+    return QString();
+}
+
+QString DBusUnitySessionService::RealName() const
+{
+    struct passwd *p = getpwuid(getuid());
+    if (p) {
+        const QString gecos = QString::fromLocal8Bit(p->pw_gecos);
+        if (!gecos.isEmpty()) {
+            return gecos.split(QLatin1Char(',')).first();
+        }
+    }
+
+    return QString();
+}
+
+QString DBusUnitySessionService::HostName() const
+{
+    char hostName[512];
+    if (gethostname(hostName, sizeof(hostName)) == -1) {
+        qWarning() << "Could not determine local hostname";
+        return QString();
+    }
+    hostName[sizeof(hostName) - 1] = '\0';
+    return QString::fromLocal8Bit(hostName);
+}
+
+void DBusUnitySessionService::PromptLock()
+{
+    Q_EMIT LockRequested();
+}
+
+void DBusUnitySessionService::Lock()
+{
+    // lock the session using the org.freedesktop.DisplayManager system DBUS service
+    const QString sessionPath = QString::fromLocal8Bit(qgetenv("XDG_SESSION_PATH"));
+    QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DisplayManager",
+                                                      sessionPath,
+                                                      "org.freedesktop.DisplayManager.Session",
+                                                      "Lock");
+    qDebug() << "Locking session" << msg.path();
+    QDBusReply<void> reply = QDBusConnection::systemBus().asyncCall(msg);
+    if (!reply.isValid()) {
+        qWarning() << "Lock call failed" << reply.error().message();
+    } else {
+        // emit Locked when the call succeeds
+        Q_EMIT Locked();
+    }
+}
+
+bool DBusUnitySessionService::IsLocked() const
+{
+    return !d->isSessionActive;
 }
 
 void DBusUnitySessionService::RequestLogout()
 {
-  Q_EMIT logoutRequested(false);
+    Q_EMIT LogoutRequested(false);
 }
 
 void DBusUnitySessionService::Reboot()
 {
-  QDBusConnection connection = QDBusConnection::systemBus();
-  QDBusInterface iface1 ("org.freedesktop.login1",
-                         "/org/freedesktop/login1",
-                         "org.freedesktop.login1.Manager",
-                         connection);
-
-  iface1.call("Reboot", false);
+    d->makeLogin1Call("Reboot", {false});
 }
 
 void DBusUnitySessionService::RequestReboot()
 {
-  Q_EMIT rebootRequested(false);
+    Q_EMIT RebootRequested(false);
 }
 
 void DBusUnitySessionService::Shutdown()
 {
-  QDBusConnection connection = QDBusConnection::systemBus();
-  QDBusInterface iface1 ("org.freedesktop.login1",
-                         "/org/freedesktop/login1",
-                         "org.freedesktop.login1.Manager",
-                         connection);
-
-  iface1.call("PowerOff", false);
+    d->makeLogin1Call("PowerOff", {false});
+}
+
+void DBusUnitySessionService::Suspend()
+{
+    d->makeLogin1Call("Suspend", {false});
+}
+
+void DBusUnitySessionService::Hibernate()
+{
+    d->makeLogin1Call("Hibernate", {false});
+}
+
+void DBusUnitySessionService::HybridSleep()
+{
+    d->makeLogin1Call("HybridSleep", {false});
 }
 
 void DBusUnitySessionService::RequestShutdown()
 {
-  Q_EMIT shutdownRequested(false);
+    Q_EMIT ShutdownRequested(false);
 }
 
 enum class Action : unsigned
 {
-  LOGOUT = 0,
-  SHUTDOWN,
-  REBOOT,
-  NONE
+    LOGOUT = 0,
+    SHUTDOWN,
+    REBOOT,
+    NONE
 };
 
+
+void performAsyncUnityCall(const QString &method)
+{
+    const QDBusMessage msg = QDBusMessage::createMethodCall("com.canonical.Unity",
+                                                            "/com/canonical/Unity/Session",
+                                                            "com.canonical.Unity.Session",
+                                                            method);
+    QDBusConnection::sessionBus().asyncCall(msg);
+}
+
+
 DBusGnomeSessionManagerWrapper::DBusGnomeSessionManagerWrapper()
     : UnityDBusObject("/org/gnome/SessionManager/EndSessionDialog", "com.canonical.Unity")
 {
 }
 
-DBusGnomeSessionManagerWrapper::~DBusGnomeSessionManagerWrapper()
-{
-}
-
 void DBusGnomeSessionManagerWrapper::Open(const unsigned type, const unsigned arg_1, const unsigned max_wait, const QList<QDBusObjectPath> &inhibitors)
 {
-  Q_UNUSED(arg_1);
-  Q_UNUSED(max_wait);
-  Q_UNUSED(inhibitors);
-
-  QDBusConnection connection = QDBusConnection::sessionBus();
-  QDBusInterface iface1 ("com.canonical.Unity",
-                         "/com/canonical/Unity/Session",
-                         "com.canonical.Unity.Session",
-                         connection);
-
-  Action action = (Action)type;
-
-  switch (action)
-  {
+    Q_UNUSED(arg_1);
+    Q_UNUSED(max_wait);
+    Q_UNUSED(inhibitors);
+
+    switch (static_cast<Action>(type))
+    {
     case Action::LOGOUT:
-      iface1.call("RequestLogout");
-      break;
+        performAsyncUnityCall("RequestLogout");
+        break;
 
     case Action::REBOOT:
-      iface1.call("RequestShutdown");
-      break;
+        performAsyncUnityCall("RequestReboot");
+        break;
 
     case Action::SHUTDOWN:
-      break;
+        performAsyncUnityCall("RequestShutdown");
+        break;
 
     default:
-      break;
-  }
-}
+        break;
+    }
+}
+
+
+DBusGnomeScreensaverWrapper::DBusGnomeScreensaverWrapper()
+    : UnityDBusObject("/org/gnome/ScreenSaver", "org.gnome.ScreenSaver")
+{
+    connect(d, &DBusUnitySessionServicePrivate::screensaverActiveChanged, this, &DBusGnomeScreensaverWrapper::ActiveChanged);
+}
+
+bool DBusGnomeScreensaverWrapper::GetActive() const
+{
+    return !d->isSessionActive; // return whether the session is not active
+}
+
+void DBusGnomeScreensaverWrapper::SetActive(bool lock)
+{
+    if (lock) {
+        Lock();
+    }
+}
+
+void DBusGnomeScreensaverWrapper::Lock()
+{
+    performAsyncUnityCall("Lock");
+}
+
+quint32 DBusGnomeScreensaverWrapper::GetActiveTime() const
+{
+    return d->screensaverActiveTime();
+}
+
+void DBusGnomeScreensaverWrapper::SimulateUserActivity()
+{
+    d->setIdleHint(false);
+}
+
+
+DBusScreensaverWrapper::DBusScreensaverWrapper()
+    : UnityDBusObject("/org/freedesktop/ScreenSaver", "org.freedesktop.ScreenSaver")
+{
+    QDBusConnection::sessionBus().registerObject("/ScreenSaver", this, QDBusConnection::ExportScriptableContents); // compat path, also register here
+    connect(d, &DBusUnitySessionServicePrivate::screensaverActiveChanged, this, &DBusScreensaverWrapper::ActiveChanged);
+}
+
+bool DBusScreensaverWrapper::GetActive() const
+{
+    return !d->isSessionActive; // return whether the session is not active
+}
+
+bool DBusScreensaverWrapper::SetActive(bool lock)
+{
+    if (lock) {
+        Lock();
+        return true;
+    }
+    return false;
+}
+
+void DBusScreensaverWrapper::Lock()
+{
+    performAsyncUnityCall("Lock");
+}
+
+quint32 DBusScreensaverWrapper::GetActiveTime() const
+{
+    return d->screensaverActiveTime();
+}
+
+quint32 DBusScreensaverWrapper::GetSessionIdleTime() const
+{
+    return QDateTime::fromMSecsSinceEpoch(d->idleSinceUSecTimestamp()/1000).secsTo(QDateTime::currentDateTime());
+}
+
+void DBusScreensaverWrapper::SimulateUserActivity()
+{
+    d->setIdleHint(false);
+}
+
+#include "dbusunitysessionservice.moc"

=== modified file 'plugins/Unity/Session/dbusunitysessionservice.h'
--- plugins/Unity/Session/dbusunitysessionservice.h	2015-03-02 12:11:03 +0000
+++ plugins/Unity/Session/dbusunitysessionservice.h	2015-06-19 11:26:12 +0000
@@ -1,5 +1,5 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
+/*
+ * Copyright (C) 2014, 2015 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License version 3, as published by
@@ -29,7 +29,7 @@
  * interface.
  *
  * com.canonical.Unity.Session interface provides public methods
- * and signals to handle Logout/Reboot/Shutdown.
+ * and signals to handle eg. Logout/Reboot/Shutdown.
  */
 class DBusUnitySessionService : public UnityDBusObject
 {
@@ -38,7 +38,7 @@
 
 public:
     DBusUnitySessionService();
-    ~DBusUnitySessionService();
+    ~DBusUnitySessionService() = default;
 
     // For use in QML. Javascript doesn't accept functions beginning with capital letters
     Q_INVOKABLE void logout() { Logout(); }
@@ -48,49 +48,63 @@
 
 Q_SIGNALS:
     /**
-     * logoutRequested signal
+     * LogoutRequested signal
      *
      * This signal is emitted when some applications request the system to
      * logout.
      * @param have_inhibitors if there are any special running applications
      *        which inhibit the logout.
      */
-    Q_SCRIPTABLE void logoutRequested(bool have_inhibitors);
+    Q_SCRIPTABLE void LogoutRequested(bool have_inhibitors);
 
     /**
-     * rebootRequested signal
+     * RebootRequested signal
      *
      * This signal is emitted when some applications request the system to
      * reboot.
      * @param have_inhibitors if there are any special running applications
      *        which inhibit the reboot.
      */
-    Q_SCRIPTABLE void rebootRequested(bool have_inhibitors);
+    Q_SCRIPTABLE void RebootRequested(bool have_inhibitors);
 
     /**
-     * shutdownRequested signal
+     * ShutdownRequested signal
      *
      * This signal is emitted when some applications request the system to
      * shutdown.
      * @param have_inhibitors if there are any special running applications
      *        which inhibit the shutdown.
      */
-    Q_SCRIPTABLE void shutdownRequested(bool have_inhibitors);
-
+    Q_SCRIPTABLE void ShutdownRequested(bool have_inhibitors);
 
     /**
-     * logoutReady signal
+     * LogoutReady signal
      *
      * This signal is emitted when all the apps are closed. And the system
      * is safe to logout.
      */
-    void logoutReady();
+    Q_SCRIPTABLE void LogoutReady();
+
+    /**
+     * Emitted as a result of calling PromptLock()
+     */
+    Q_SCRIPTABLE void LockRequested();
+
+    /**
+     * Emitted after the session has been locked.
+     */
+    Q_SCRIPTABLE void Locked();
+
+    /**
+     * Emitted after the session has been unlocked.
+     */
+    Q_SCRIPTABLE void Unlocked();
 
 public Q_SLOTS:
     /**
      * Logout the system.
      *
-     * This method directly logout the system without user's confirmation.
+     * This method directly logs out the system without user's confirmation.
      * Ordinary applications should avoid calling this method. Please call
      * RequestLogout() to ask the user to decide logout or not.
      */
@@ -99,7 +113,7 @@
     /**
      * Reboot the system.
      *
-     * This method directly reboot the system without user's confirmation.
+     * This method directly reboots the system without user's confirmation.
      * Ordinary applications should avoid calling this method. Please call
      * RequestReboot() to ask the user to decide reboot or not.
      */
@@ -108,16 +122,39 @@
     /**
      * Shutdown the system.
      *
-     * This method directly shutdown the system without user's confirmation.
+     * This method directly shuts down the system without user's confirmation.
      * Ordinary applications should avoid calling this method. Please call
      * RequestShutdown() to ask the user to decide shutdown or not.
      */
     Q_SCRIPTABLE void Shutdown();
 
     /**
+     * Suspend the system
+     *
+     * This method puts the system into sleep without user's confirmation.
+     */
+    Q_SCRIPTABLE void Suspend();
+
+    /**
+     * Hibernate the system
+     *
+     * This method puts the system into hibernation without user's confirmation.
+     */
+    Q_SCRIPTABLE void Hibernate();
+
+    /**
+     * Hybrid sleep
+     *
+     * This method puts the system into hybrid sleep without user's confirmation.
+     *
+     * @since unity8
+     */
+    Q_SCRIPTABLE void HybridSleep();
+
+    /**
      * Issue a logout request.
      *
-     * This method emit the logoutRequested signal to the shell with a boolean
+     * This method emits the LogoutRequested signal to the shell with a boolean
      * which indicates if there's any inhibitors. The shell should receive
      * this signal and display a dialog to ask the user to confirm the logout
      * action. If confirmed, shell can call Logout() method to logout.
@@ -127,21 +164,21 @@
     /**
      * Issue a reboot request.
      *
-     * This method emit the rebootRequested signal to the shell with a boolean
+     * This method emits the RebootRequested signal to the shell with a boolean
      * which indicates if there's any inhibitors. The shell should receive
      * this signal and display a dialog to ask the user to confirm the reboot
-     * action. If confirmed, shell can call Reboot() method to reboot
+     * action. If confirmed, shell can call Reboot() method to reboot.
      */
     Q_SCRIPTABLE void RequestReboot();
 
     /**
      * Issue a shutdown request.
      *
-     * This method emit the shutdownRequested signal to the shell with a
+     * This method emits the ShutdownRequested signal to the shell with a
      * boolean which indicates if there's any inhibitors.
      * The shell should receive
      * this signal and display a dialog to ask the user to confirm the reboot
-     * action. If confirmed, shell can call Shutdown() method to reboot
+     * action. If confirmed, shell can call Shutdown() method to shutdown.
      */
     Q_SCRIPTABLE void RequestShutdown();
 
@@ -152,6 +189,68 @@
      * current DBus session bus.
      */
     Q_SCRIPTABLE void EndSession();
+
+    /**
+     * @return whether the system is capable of hibernating
+     */
+    Q_SCRIPTABLE bool CanHibernate() const;
+
+    /**
+     * @return whether the system is capable of suspending
+     */
+    Q_SCRIPTABLE bool CanSuspend() const;
+
+    /**
+     * @return whether the system is capable of hybrid sleep
+     * @since unity8
+     */
+    Q_SCRIPTABLE bool CanHybridSleep() const;
+
+    /**
+     * @return whether the system is capable of rebooting
+     * @since unity8
+     */
+    Q_SCRIPTABLE bool CanReboot() const;
+
+    /**
+     * @return whether the system is capable of shutting down
+     */
+    Q_SCRIPTABLE bool CanShutdown() const;
+
+    /**
+     * @return whether the system is capable of locking the session
+     */
+    Q_SCRIPTABLE bool CanLock() const;
+
+    /**
+     * @return the login name of the current user
+     */
+    Q_SCRIPTABLE QString UserName() const;
+
+    /**
+     * @return the real name of the current user
+     */
+    Q_SCRIPTABLE QString RealName() const;
+
+    /**
+     * @return the local hostname
+     */
+    Q_SCRIPTABLE QString HostName() const;
+
+    /**
+     * Request that the session get locked, emits signal LockRequested()
+     */
+    Q_SCRIPTABLE void PromptLock();
+
+    /**
+     * Locks the session immediately
+     */
+    Q_SCRIPTABLE void Lock();
+
+    /**
+     * @return whether the session is currently locked
+     */
+    Q_SCRIPTABLE bool IsLocked() const;
 };
 
 class DBusGnomeSessionManagerWrapper : public UnityDBusObject
@@ -161,9 +260,87 @@
 
 public:
     DBusGnomeSessionManagerWrapper();
-    ~DBusGnomeSessionManagerWrapper();
+    ~DBusGnomeSessionManagerWrapper() = default;
 
 public Q_SLOTS:
     Q_SCRIPTABLE void Open(const unsigned int type, const unsigned int arg_1, const unsigned int max_wait, const QList<QDBusObjectPath> &inhibitors);
 };
+
+class DBusGnomeScreensaverWrapper: public UnityDBusObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.gnome.ScreenSaver")
+
+public:
+    DBusGnomeScreensaverWrapper();
+    ~DBusGnomeScreensaverWrapper() = default;
+
+public Q_SLOTS:
+    /**
+     * @return whether the session is currently locked (screensaver is on)
+     */
+    Q_SCRIPTABLE bool GetActive() const;
+
+    /**
+     * Locks the session immediately if @p lock is true
+     */
+    Q_SCRIPTABLE void SetActive(bool lock);
+
+    /**
+     * Locks the session immediately
+     */
+    Q_SCRIPTABLE void Lock();
+
+    /**
+     * @return the number of seconds elapsed since the screensaver had been active
+     */
+    Q_SCRIPTABLE quint32 GetActiveTime() const;
+
+    Q_SCRIPTABLE void SimulateUserActivity();
+
+Q_SIGNALS:
+    void ActiveChanged(bool active);
+};
+
+class DBusScreensaverWrapper: public UnityDBusObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.freedesktop.ScreenSaver")
+
+public:
+    DBusScreensaverWrapper();
+    ~DBusScreensaverWrapper() = default;
+
+public Q_SLOTS:
+    /**
+     * @return whether the session is currently locked (screensaver is on)
+     */
+    Q_SCRIPTABLE bool GetActive() const;
+
+    /**
+     * Locks the session immediately if @p lock is true
+     */
+    Q_SCRIPTABLE bool SetActive(bool lock);
+
+    /**
+     * Locks the session immediately
+     */
+    Q_SCRIPTABLE void Lock();
+
+    /**
+     * @return the number of seconds elapsed since the screensaver had been active
+     */
+    Q_SCRIPTABLE quint32 GetActiveTime() const;
+
+    /**
+     * @return the number of seconds that this session has been idle
+     */
+    Q_SCRIPTABLE quint32 GetSessionIdleTime() const;
+
+    Q_SCRIPTABLE void SimulateUserActivity();
+
+Q_SIGNALS:
+    void ActiveChanged(bool active);
+};
+
 #endif // DBUSUNITYSESSIONSERVICE_H

=== modified file 'plugins/Utils/relativetimeformatter.cpp'
--- plugins/Utils/relativetimeformatter.cpp	2014-10-21 19:28:01 +0000
+++ plugins/Utils/relativetimeformatter.cpp	2015-06-19 11:26:12 +0000
@@ -121,7 +121,7 @@
 const char*
 dgettext_datetime(const char *text)
 {
-    return dgettext("indicator-datetime", text);
+    return dgettext("unity8", text);
 }
 
 /**

=== modified file 'plugins/Wizard/System.cpp'
--- plugins/Wizard/System.cpp	2014-11-19 17:43:09 +0000
+++ plugins/Wizard/System.cpp	2015-06-19 11:26:12 +0000
@@ -16,7 +16,9 @@
 
 #include "System.h"
 
-#include <QDBusInterface>
+#include <QDBusPendingCall>
+#include <QDBusMessage>
+#include <QDBusConnection>
 #include <QDBusMetaType>
 #include <QDir>
 #include <QFile>
@@ -65,21 +67,23 @@
 void System::setSessionVariable(const QString &variable, const QString &value)
 {
     // We need to update both upstart's and DBus's environment
-    QProcess::execute(QString("initctl set-env --global %1=%2").arg(variable, value));
-
-    QDBusInterface iface("org.freedesktop.DBus",
-                         "/org/freedesktop/DBus",
-                         "org.freedesktop.DBus",
-                         QDBusConnection::sessionBus());
+    QProcess::startDetached(QStringLiteral("initctl set-env --global %1=%2").arg(variable, value));
 
     QMap<QString,QString> valueMap;
     valueMap.insert(variable, value);
-    iface.call("UpdateActivationEnvironment", QVariant::fromValue(valueMap));
+
+    QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DBus",
+                                                      "/org/freedesktop/DBus",
+                                                      "org.freedesktop.DBus",
+                                                      "UpdateActivationEnvironment");
+
+    msg << QVariant::fromValue(valueMap);
+    QDBusConnection::sessionBus().asyncCall(msg);
 }
 
 void System::updateSessionLanguage(const QString &locale)
 {
-    QString language = locale.split(".")[0];
+    const QString language = locale.split(".")[0];
 
     setSessionVariable("LANGUAGE", language);
     setSessionVariable("LANG", locale);

=== modified file 'tests/plugins/AccountsService/client.cpp'
--- tests/plugins/AccountsService/client.cpp	2015-04-17 16:44:28 +0000
+++ tests/plugins/AccountsService/client.cpp	2015-06-19 11:26:12 +0000
@@ -94,8 +94,7 @@
 
     void testGetSetService()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.demoEdges(), false);
         session.setDemoEdges(true);
@@ -112,8 +111,7 @@
 
     void testAsynchornousChangeForDemoEdges()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.demoEdges(), false);
         ASSERT_DBUS_CALL(m_userInterface->call("Set",
@@ -125,8 +123,7 @@
 
     void testAsynchornousChangeForFailedLogins()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.failedLogins(), (uint)0);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -138,8 +135,7 @@
 
     void testAsynchornousChangeForStatsWelcomeScreen()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.statsWelcomeScreen(), true);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -151,8 +147,7 @@
 
     void testAsynchornousChangeForStatsEnableLauncherWhileLocked()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.enableLauncherWhileLocked(), true);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -164,8 +159,7 @@
 
     void testAsynchornousChangeForStatsEnableIndicatorsWhileLocked()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.enableIndicatorsWhileLocked(), true);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -177,8 +171,7 @@
 
     void testAsynchornousChangeForStatsPasswordDisplayHint()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.passwordDisplayHint(), AccountsService::Keyboard);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -190,8 +183,7 @@
 
     void testAsynchornousChangeForStatsLicenseAccepted()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.hereEnabled(), false);
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -203,8 +195,7 @@
 
     void testAsynchornousChangeForLicenseBasePath()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.hereLicensePath(), QString());
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
@@ -216,8 +207,7 @@
 
     void testAsynchornousChangeForStatsBackgroundFile()
     {
-        AccountsService session;
-        session.setUser(QTest::currentTestFunction());
+        AccountsService session(this, QTest::currentTestFunction());
 
         QCOMPARE(session.backgroundFile(), QString());
         ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",

=== modified file 'tests/plugins/Unity/Session/sessionbackendtest.cpp'
--- tests/plugins/Unity/Session/sessionbackendtest.cpp	2015-02-03 10:52:07 +0000
+++ tests/plugins/Unity/Session/sessionbackendtest.cpp	2015-06-19 11:26:12 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 Canonical Ltd.
+ * Copyright 2013-2015 Canonical Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -15,6 +15,7 @@
  *
  * Authors:
  *      Ying-Chun Liu (PaulLiu) <[e-mail]>
+ *      Lukáš Tinkl <[e-mail]>
  */
 
 #include <QtTest>
@@ -23,6 +24,11 @@
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QDBusVariant>
+#include <QDebug>
+#include <QDBusObjectPath>
+
+#include <unistd.h>
+#include <sys/types.h>
 
 #include "dbusunitysessionservice.h"
 
@@ -49,17 +55,23 @@
 
     void testUnitySessionLogoutRequested_data() {
         QTest::addColumn<QString>("method");
+        QTest::addColumn<QString>("signal");
 
-        QTest::newRow("Logout") << "RequestLogout";
+        QTest::newRow("Logout") << "RequestLogout" << "LogoutRequested(bool)";
+        QTest::newRow("Reboot") << "RequestReboot" << "RebootRequested(bool)";
+        QTest::newRow("Shutdown") << "RequestShutdown" << "ShutdownRequested(bool)";
+        QTest::newRow("PromptLock") << "PromptLock" << "LockRequested()";
     }
 
     void testUnitySessionLogoutRequested() {
         QFETCH(QString, method);
+        QFETCH(QString, signal);
 
         DBusUnitySessionService dbusUnitySessionService;
         QCoreApplication::processEvents(); // to let the service register on DBus
 
-        QSignalSpy spy(&dbusUnitySessionService, SIGNAL(logoutRequested(bool)));
+        // .. because QSignalSpy checks the signal signature like this: "if (((aSignal[0] - '0') & 0x03) != QSIGNAL_CODE)"
+        QSignalSpy spy(&dbusUnitySessionService, qPrintable(signal.prepend(QSIGNAL_CODE)));
 
         QDBusReply<void> reply = dbusUnitySession->call(method);
         QCOMPARE(reply.isValid(), true);
@@ -67,67 +79,106 @@
         QCOMPARE(spy.count(), 1);
     }
 
-    void testGnomeSessionWrapperLogoutRequested() {
-        DBusUnitySessionService dbusUnitySessionService;
-        QCoreApplication::processEvents(); // to let the service register on DBus
-
-        // Spy on the logoutRequested signal on the /com/canonical/Unity/Session object
-        // as proof we are actually calling the actual method.
-        QSignalSpy spy(&dbusUnitySessionService, SIGNAL(logoutRequested(bool)));
-
-        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
-        QCoreApplication::processEvents(); // to let the service register on DBus
-
-        QDBusInterface dbusGnomeSessionWrapper ("com.canonical.Unity",
-                                                "/org/gnome/SessionManager/EndSessionDialog",
-                                                "org.gnome.SessionManager.EndSessionDialog",
-                                                QDBusConnection::sessionBus());
-
-        QCOMPARE(dbusGnomeSessionWrapper.isValid(), true);
-
-        // Set the QVariant as a QList<QDBusObjectPath> type
-        QDbusList var;
-        QVariant inhibitors;
-        inhibitors.setValue(var);
-
-        QDBusReply<void> reply = dbusGnomeSessionWrapper.call("Open", (unsigned)Action::LOGOUT, (unsigned)0, (unsigned)0, inhibitors);
-        QCOMPARE(reply.isValid(), true);
-
-        // Make sure we see the signal being emitted.
-        QCOMPARE(spy.count(), 1);
-    }
-
-    void testGnomeSessionWrapperShutdownRequested() {
-        DBusUnitySessionService dbusUnitySessionService;
-        QCoreApplication::processEvents(); // to let the service register on DBus
-
-        // Spy on the shutdownRequested signal on the /com/canonical/Unity/Session object
-        // as proof we are actually calling the actual method.
-        QSignalSpy spy(&dbusUnitySessionService, SIGNAL(shutdownRequested(bool)));
-
-        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
-        QCoreApplication::processEvents(); // to let the service register on DBus
-
-        QDBusInterface dbusGnomeSessionWrapper ("com.canonical.Unity",
-                                                "/org/gnome/SessionManager/EndSessionDialog",
-                                                "org.gnome.SessionManager.EndSessionDialog",
-                                                QDBusConnection::sessionBus());
-
-        QCOMPARE(dbusGnomeSessionWrapper.isValid(), true);
-
-        // Set the QVariant as a QList<QDBusObjectPath> type
-        QDbusList var;
-        QVariant inhibitors;
-        inhibitors.setValue(var);
-
-        // * Reboot action translates to the shutdown signal due to some weird idiosyncracy
-        //   in the indicator-session/Unity interaction. *
-        QDBusReply<void> reply = dbusGnomeSessionWrapper.call("Open", (unsigned)Action::REBOOT, (unsigned)0, (unsigned)0, inhibitors);
-        QCOMPARE(reply.isValid(), true);
-
-        // Make sure we see the signal being emitted.
-        QCOMPARE(spy.count(), 1);
-    }
+    void testGnomeSessionWrapper_data() {
+        QTest::addColumn<uint>("method");
+        QTest::addColumn<QString>("signal");
+
+        QTest::newRow("Logout") << (uint)Action::LOGOUT << "LogoutRequested(bool)";
+        QTest::newRow("Shutdown") << (uint)Action::SHUTDOWN << "ShutdownRequested(bool)";
+        QTest::newRow("Reboot") << (uint)Action::REBOOT << "RebootRequested(bool)";
+    }
+
+    void testGnomeSessionWrapper() {
+        QFETCH(uint, method);
+        QFETCH(QString, signal);
+
+        DBusUnitySessionService dbusUnitySessionService;
+        QCoreApplication::processEvents(); // to let the service register on DBus
+
+        // Spy on the given signal on the /com/canonical/Unity/Session object
+        // as proof we are actually calling the actual method.
+        // .. because QSignalSpy checks the signal signature like this: "if (((aSignal[0] - '0') & 0x03) != QSIGNAL_CODE)"
+        QSignalSpy spy(&dbusUnitySessionService, qPrintable(signal.prepend(QSIGNAL_CODE)));
+
+        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
+        QCoreApplication::processEvents(); // to let the service register on DBus
+
+        QDBusInterface dbusGnomeSessionWrapper("com.canonical.Unity",
+                                               "/org/gnome/SessionManager/EndSessionDialog",
+                                               "org.gnome.SessionManager.EndSessionDialog",
+                                               QDBusConnection::sessionBus());
+
+        QCOMPARE(dbusGnomeSessionWrapper.isValid(), true);
+
+        // Set the QVariant as a QList<QDBusObjectPath> type
+        QDbusList var;
+        QVariant inhibitors;
+        inhibitors.setValue(var);
+
+        QDBusReply<void> reply = dbusGnomeSessionWrapper.call("Open", method, (unsigned)0, (unsigned)0, inhibitors);
+        QCOMPARE(reply.isValid(), true);
+
+        // Make sure we see the signal being emitted.
+        QCOMPARE(spy.count(), 1);
+    }
+
+    void testUserName() {
+        DBusUnitySessionService dbusUnitySessionService;
+        QCoreApplication::processEvents(); // to let the service register on DBus
+
+        QCOMPARE(dbusUnitySessionService.UserName(), QString::fromUtf8(qgetenv("USER")));
+    }
+
+    void testRealName() {
+        DBusUnitySessionService dbusUnitySessionService;
+        QCoreApplication::processEvents(); // to let the service register on DBus
+
+        QDBusInterface accIface("org.freedesktop.Accounts", "/org/freedesktop/Accounts", "org.freedesktop.Accounts", QDBusConnection::systemBus());
+        QVERIFY(accIface.isValid());
+        QDBusReply<QDBusObjectPath> userPath = accIface.asyncCall("FindUserById", static_cast<qint64>(geteuid()));
+        if (!userPath.isValid()) {
+            QFAIL("Could not get user path in Account Service");
+        }
+
+        QDBusInterface userAccIface("org.freedesktop.Accounts", userPath.value().path(), "org.freedesktop.Accounts.User", QDBusConnection::systemBus());
+        QCOMPARE(dbusUnitySessionService.RealName(), userAccIface.property("RealName").toString());
+    }
+
+    void testLogin1Capabilities() {
+        DBusUnitySessionService dbusUnitySessionService;
+        QDBusInterface login1face("org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", QDBusConnection::systemBus());
+        QCoreApplication::processEvents(); // to let the services register on DBus
+
+        QCOMPARE(dbusUnitySessionService.CanHibernate(), (login1face.call("CanHibernate").arguments().first().toString() != "no"));
+        QCOMPARE(dbusUnitySessionService.CanSuspend(), (login1face.call("CanSuspend").arguments().first().toString() != "no"));
+        QCOMPARE(dbusUnitySessionService.CanReboot(), (login1face.call("CanReboot").arguments().first().toString() != "no"));
+        QCOMPARE(dbusUnitySessionService.CanShutdown(), (login1face.call("CanPowerOff").arguments().first().toString() != "no"));
+        QCOMPARE(dbusUnitySessionService.CanHybridSleep(), (login1face.call("CanHybridSleep").arguments().first().toString() != "no"));
+    }
+
+//    void testLock() {
+//        DBusUnitySessionService dbusUnitySessionService;
+//        DBusScreensaverWrapper saverIface;
+//        QDBusInterface saverCompatIface("org.freedesktop.ScreenSaver", "/ScreenSaver", "org.freedesktop.ScreenSaver", QDBusConnection::sessionBus());
+//        QSignalSpy spy(&saverIface, &DBusScreensaverWrapper::ActiveChanged);
+//        QCoreApplication::processEvents(); // to let the service register on DBus
+
+//        QTRY_COMPARE(saverCompatIface.isValid(), true);
+
+//        qDebug() << "Locking up...";
+//        dbusUnitySessionService.Lock();
+
+//        QTRY_COMPARE(spy.count(), 1);
+//        QList<QVariant> arguments = spy.takeFirst(); // take the first signal
+//        QVERIFY(arguments.at(0).toBool() == true); // verify the first argument
+
+//        // verify the session is locked
+//        QCOMPARE(saverIface.GetActive(), true);
+
+//        sleep(5);
+//        qDebug() << "Screensaver has been active for" << saverIface.GetActiveTime() << "seconds";
+//        qDebug() << "Session has been idle for" << saverIface.GetSessionIdleTime() << "seconds";
+//    }
 
 private:
     QDBusInterface *dbusUnitySession;