Merge into trunk : gnome-session-quit : Code : Unity 8

Status:

Merged

Approved by:

Albert Astals Cid on 2017-03-17

Approved revision:

2870

Merged at revision:

2869

Proposed branch:

lp:~mterry/unity8/gnome-session-quit

Merge into:

lp:unity8

Diff against target:

291 lines (+186/-8)

6 files modified

plugins/Unity/Session/dbusunitysessionservice.cpp (+46/-1)
plugins/Unity/Session/dbusunitysessionservice.h (+18/-4)
tests/plugins/Unity/Session/LogindServer.cpp (+10/-0)
tests/plugins/Unity/Session/LogindServer.h (+5/-0)
tests/plugins/Unity/Session/interfaces.xml (+12/-0)
tests/plugins/Unity/Session/sessionbackendtest.cpp (+95/-3)

To merge this branch:

bzr merge lp:~mterry/unity8/gnome-session-quit

Low

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Albert Astals Cid (community)		2017-03-15	Approve on 2017-03-17
Unity8 CI Bot	continuous-integration		Approve on 2017-03-16
Review via email: mp+319992@code.launchpad.net

Commit Message

Support GNOME-style logout DBus API (making the Logout, Reboot, and Shutdown launcher commands work)

Description of the Change

As noted in bug 1673229, the launcher items "Logout", "Shutdown", and "Reboot" don't do anything in unity8. They are holdovers from GNOME, making calls to the org.gnome.SessionManager interface.

Despite being old-world commands, it would still be nice if we supported them (and other bits of code in classic Ubuntu might try similar calls to the API). Unity7 supports them. And we support the similar (older?) org.gnome.SessionManager.EndSessionDialog interface. So this is a small change for us.

You can test by logging into deb-based unity8 and running those commands from the launcher. There's still a momentary, jarring splash window created for the command. But that's a separate issue.

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-15:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/3403/rebuild

review: Needs Fixing (continuous-integration)

lp:~mterry/unity8/gnome-session-quit updated on 2017-03-16

2870. By Michael Terry on 2017-03-16: Drop extra whitespace

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-16:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/3417/rebuild

review: Approve (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-16:

#

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/3422/rebuild

review: Approve (continuous-integration)

Albert Astals Cid (aacid) wrote on 2017-03-17:

#

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

* Did CI run pass? If not, please explain why.
Yes

review: Approve

Unity 8

Merge lp:~mterry/unity8/gnome-session-quit into lp:unity8

Commit Message

Description of the Change

Preview Diff

Subscribers

 === modified file 'plugins/Unity/Session/dbusunitysessionservice.cpp'
 --- plugins/Unity/Session/dbusunitysessionservice.cpp	2016-12-19 19:55:07 +0000
 +++ plugins/Unity/Session/dbusunitysessionservice.cpp	2017-03-16 14:04:06 +0000
@@ -468,11 +468,56 @@
  DBusGnomeSessionManagerWrapper::DBusGnomeSessionManagerWrapper()
++    : UnityDBusObject(QStringLiteral("/org/gnome/SessionManager"), QStringLiteral("org.gnome.SessionManager"))
++{
++}
++
++void DBusGnomeSessionManagerWrapper::Logout(quint32 mode)
++{
++    auto call = QStringLiteral("RequestLogout");
++
++    // These modes are documented as bitwise flags, not an enum, even though
++    // they only ever seem to be used as enums.
++
++    if (mode & 1) // without dialog
++        call = QStringLiteral("Logout");
++    if (mode & 2) // without dialog, ignoring inhibitors (which we don't have)
++        call = QStringLiteral("Logout");
++
++    performAsyncUnityCall(call);
++}
++
++void DBusGnomeSessionManagerWrapper::Reboot()
++{
++    // GNOME's Reboot means with dialog (they use Request differently than us).
++    performAsyncUnityCall(QStringLiteral("RequestReboot"));
++}
++
++void DBusGnomeSessionManagerWrapper::RequestReboot()
++{
++    // GNOME's RequestReboot means no dialog (they use Request differently than us).
++    performAsyncUnityCall(QStringLiteral("Reboot"));
++}
++
++void DBusGnomeSessionManagerWrapper::RequestShutdown()
++{
++    // GNOME's RequestShutdown means no dialog (they use Request differently than us).
++    performAsyncUnityCall(QStringLiteral("Shutdown"));
++}
++
++void DBusGnomeSessionManagerWrapper::Shutdown()
++{
++    // GNOME's Shutdown means with dialog (they use Request differently than us).
++    performAsyncUnityCall(QStringLiteral("RequestShutdown"));
++}
++
++
++DBusGnomeSessionManagerDialogWrapper::DBusGnomeSessionManagerDialogWrapper()
      : UnityDBusObject(QStringLiteral("/org/gnome/SessionManager/EndSessionDialog"), QStringLiteral("com.canonical.Unity"))
+ {
+ }
--void DBusGnomeSessionManagerWrapper::Open(const unsigned type, const unsigned arg_1, const unsigned max_wait, const QList<QDBusObjectPath> &inhibitors)
++void DBusGnomeSessionManagerDialogWrapper::Open(const unsigned type, const unsigned arg_1, const unsigned max_wait, const QList<QDBusObjectPath> &inhibitors)
+ {
      Q_UNUSED(arg_1);
      Q_UNUSED(max_wait);
 === modified file 'plugins/Unity/Session/dbusunitysessionservice.h'
 --- plugins/Unity/Session/dbusunitysessionservice.h	2016-12-19 19:55:07 +0000
 +++ plugins/Unity/Session/dbusunitysessionservice.h	2017-03-16 14:04:06 +0000
@@ -270,17 +270,31 @@
  class DBusGnomeSessionManagerWrapper : public UnityDBusObject
+ {
      Q_OBJECT
--    Q_CLASSINFO("D-Bus Interface", "org.gnome.SessionManager.EndSessionDialog")
++    Q_CLASSINFO("D-Bus Interface", "org.gnome.SessionManager")
  public:
      DBusGnomeSessionManagerWrapper();
      ~DBusGnomeSessionManagerWrapper() = default;
  public Q_SLOTS:
++    Q_SCRIPTABLE void Logout(quint32 mode);
++    Q_SCRIPTABLE void Reboot();
++    Q_SCRIPTABLE void RequestReboot();
++    Q_SCRIPTABLE void RequestShutdown();
++    Q_SCRIPTABLE void Shutdown();
++};
++
++class DBusGnomeSessionManagerDialogWrapper : public UnityDBusObject
++{
++    Q_OBJECT
++    Q_CLASSINFO("D-Bus Interface", "org.gnome.SessionManager.EndSessionDialog")
++
++public:
++    DBusGnomeSessionManagerDialogWrapper();
++    ~DBusGnomeSessionManagerDialogWrapper() = 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);
--
--private:
--    void performAsyncCall(const QString &method);
  };
  class DBusGnomeScreensaverWrapper: public UnityDBusObject
 === modified file 'tests/plugins/Unity/Session/LogindServer.cpp'
 --- tests/plugins/Unity/Session/LogindServer.cpp	2016-06-22 13:38:16 +0000
 +++ tests/plugins/Unity/Session/LogindServer.cpp	2017-03-16 14:04:06 +0000
@@ -27,6 +27,16 @@
      return QDBusObjectPath("/logindsession");
+ }
++void LogindServer::Reboot(bool interactive)
++{
++    Q_EMIT RebootCalled(interactive);
++}
++
++void LogindServer::PowerOff(bool interactive)
++{
++    Q_EMIT PowerOffCalled(interactive);
++}
++
  void LogindServer::MockEmitUnlock()
+ {
      Q_EMIT Unlock();
 === modified file 'tests/plugins/Unity/Session/LogindServer.h'
 --- tests/plugins/Unity/Session/LogindServer.h	2016-06-22 13:38:16 +0000
 +++ tests/plugins/Unity/Session/LogindServer.h	2017-03-16 14:04:06 +0000
@@ -31,6 +31,8 @@
  public Q_SLOTS:
      QDBusObjectPath GetSessionByPID(quint32 pid);
++    void Reboot(bool interactive);
++    void PowerOff(bool interactive);
      void MockEmitUnlock(); // only in mock
@@ -38,6 +40,9 @@
      void Lock();
      void Unlock();
      void PrepareForSleep();
++
++    void RebootCalled(bool interactive); // only in mock
++    void PowerOffCalled(bool interactive); // only in mock
  };
  #endif
 === modified file 'tests/plugins/Unity/Session/interfaces.xml'
 --- tests/plugins/Unity/Session/interfaces.xml	2016-06-22 13:38:16 +0000
 +++ tests/plugins/Unity/Session/interfaces.xml	2017-03-16 14:04:06 +0000
@@ -7,6 +7,18 @@
        <arg name="pid" type="u" direction="in" />
        <arg name="session" type="o" direction="out" />
      </method>
++    <method name="Reboot">
++      <arg name="interactive" type="b" direction="in" />
++    </method>
++    <method name="PowerOff">
++      <arg name="interactive" type="b" direction="in" />
++    </method>
++    <signal name="RebootCalled">
++      <arg name="interactive" type="b" direction="out" />
++    </signal>
++    <signal name="PowerOffCalled">
++      <arg name="interactive" type="b" direction="out" />
++    </signal>
      <signal name="PrepareForSleep" />
    </interface>
    <interface name="org.freedesktop.login1.Session">
 === modified file 'tests/plugins/Unity/Session/sessionbackendtest.cpp'
 --- tests/plugins/Unity/Session/sessionbackendtest.cpp	2016-12-19 19:55:07 +0000
 +++ tests/plugins/Unity/Session/sessionbackendtest.cpp	2017-03-16 14:04:06 +0000
@@ -81,7 +81,99 @@
          QTRY_COMPARE(spy.count(), 1);
+     }
--    void testGnomeSessionWrapper_data() {
++    void testGnomeSessionWrapperWithoutConfirmation_data() {
++        QTest::addColumn<QString>("method");
++        QTest::addColumn<QString>("signal");
++
++        QTest::newRow("Reboot") << "RequestReboot" << SIGNAL(RebootCalled(bool));
++        QTest::newRow("Shutdown") << "RequestShutdown" << SIGNAL(PowerOffCalled(bool));
++    }
++
++    void testGnomeSessionWrapperWithoutConfirmation() {
++        QFETCH(QString, method);
++        QFETCH(QString, signal);
++
++        DBusUnitySessionService dbusUnitySessionService;
++        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
++        QCoreApplication::processEvents(); // to let the services register on DBus
++
++        QDBusInterface login1Interface("org.freedesktop.login1",
++                                      "/logindsession",
++                                      "org.freedesktop.login1.Manager");
++        QSignalSpy spy(&login1Interface, signal.toUtf8().data());
++
++        QDBusInterface dbusGnomeSessionWrapper("org.gnome.SessionManager",
++                                               "/org/gnome/SessionManager",
++                                               "org.gnome.SessionManager",
++                                               QDBusConnection::sessionBus());
++        QVERIFY(dbusGnomeSessionWrapper.isValid());
++
++        QDBusReply<void> reply = dbusGnomeSessionWrapper.call(method);
++        QVERIFY(reply.isValid());
++        QTRY_COMPARE(spy.count(), 1);
++    }
++
++    void testGnomeSessionWrapperWithConfirmation_data() {
++        QTest::addColumn<QString>("method");
++        QTest::addColumn<QString>("signal");
++
++        QTest::newRow("Reboot") << "Reboot" << SIGNAL(RebootRequested(bool));
++        QTest::newRow("Shutdown") << "Shutdown" << SIGNAL(ShutdownRequested(bool));
++    }
++
++    void testGnomeSessionWrapperWithConfirmation() {
++        QFETCH(QString, method);
++        QFETCH(QString, signal);
++
++        DBusUnitySessionService dbusUnitySessionService;
++        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
++        QCoreApplication::processEvents(); // to let the services register on DBus
++
++        QSignalSpy spy(&dbusUnitySessionService, signal.toUtf8().data());
++
++        QDBusInterface dbusGnomeSessionWrapper("org.gnome.SessionManager",
++                                               "/org/gnome/SessionManager",
++                                               "org.gnome.SessionManager",
++                                               QDBusConnection::sessionBus());
++        QVERIFY(dbusGnomeSessionWrapper.isValid());
++
++        QDBusReply<void> reply = dbusGnomeSessionWrapper.call(method);
++        QVERIFY(reply.isValid());
++        QCOMPARE(spy.count(), 1);
++    }
++
++    void testGnomeSessionWrapperLogout_data() {
++        QTest::addColumn<int>("mode");
++        QTest::addColumn<QString>("signal");
++
++        QTest::newRow("Logout") << 0 << SIGNAL(LogoutRequested(bool));
++        QTest::newRow("LogoutNoDialog") << 1 << SIGNAL(LogoutReady());
++        QTest::newRow("LogoutNoInhibits") << 2 << SIGNAL(LogoutReady());
++        QTest::newRow("LogoutNoDialogNoInhibits") << 3 << SIGNAL(LogoutReady());
++    }
++
++    void testGnomeSessionWrapperLogout() {
++        QFETCH(int, mode);
++        QFETCH(QString, signal);
++
++        DBusUnitySessionService dbusUnitySessionService;
++        DBusGnomeSessionManagerWrapper dbusGnomeSessionManagerWrapper;
++        QCoreApplication::processEvents(); // to let the services register on DBus
++
++        QSignalSpy spy(&dbusUnitySessionService, signal.toUtf8().data());
++
++        QDBusInterface dbusGnomeSessionWrapper("org.gnome.SessionManager",
++                                               "/org/gnome/SessionManager",
++                                               "org.gnome.SessionManager",
++                                               QDBusConnection::sessionBus());
++        QVERIFY(dbusGnomeSessionWrapper.isValid());
++
++        QDBusReply<void> reply = dbusGnomeSessionWrapper.call("Logout", (quint32)mode);
++        QVERIFY(reply.isValid());
++        QCOMPARE(spy.count(), 1);
++    }
++
++    void testGnomeSessionDialogWrapper_data() {
          QTest::addColumn<uint>("method");
          QTest::addColumn<QString>("signal");
@@ -90,7 +182,7 @@
          QTest::newRow("Reboot") << (uint)Action::REBOOT << "RebootRequested(bool)";
+     }
--    void testGnomeSessionWrapper() {
++    void testGnomeSessionDialogWrapper() {
          QFETCH(uint, method);
          QFETCH(QString, signal);
@@ -102,7 +194,7 @@
          // .. 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;
++        DBusGnomeSessionManagerDialogWrapper dbusGnomeSessionManagerDialogWrapper;
          QCoreApplication::processEvents(); // to let the service register on DBus
          QDBusInterface dbusGnomeSessionWrapper("com.canonical.Unity",