Merge lp:~mardy/ubuntu-system-settings-online-accounts/master into lp:ubuntu-system-settings-online-accounts

[Alberto Mardegan]

New version

- Use signon-ui-service, to fix co-installation with of signon-ui.
- Implement reauthentication (via snap-decisions)

New version

- Use signon-ui-service, to fix co-installation with of signon-ui.
- Implement reauthentication (via snap-decisions)

[Alexandre Abreu (abreu-alexandre)]

So the signon-ui-service package provides the removed bits I guess ?

review: Needs Information

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:122
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/122/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/15
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/15/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/15

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/122/rebuild

review: Approve (continuous-integration)

[Alberto Mardegan (mardy)]

> So the signon-ui-service package provides the removed bits I guess ?

Yes, the .service files are being moved there.

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

123. By Alberto Mardegan on 2014-06-05

Click hooks: remove stale file, handle updates

Remove the installed files when the click hook files get removed (meaning that an application has been unregistered).
Update the installed files when the date of the click hook file is newer.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:123
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/123/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/16
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/16/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/16

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/123/rebuild

review: Approve (continuous-integration)

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

124. By Alberto Mardegan on 2014-06-06

Add a Notification class to wrap libnotify

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:124
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/124/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/17/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/124/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

125. By Alberto Mardegan on 2014-06-06

Minor reformatting of debian rules

This allows Jenkins hooks to enable coverage.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:125
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/125/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/18
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/18
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/18/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/18

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/125/rebuild

review: Approve (continuous-integration)

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

126. By Alberto Mardegan on 2014-06-12

Add ApplicationManager::applicationFromProfile()

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:126
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/126/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/19
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/19
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/19/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/19

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/126/rebuild

review: Approve (continuous-integration)

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

127. By Alberto Mardegan on 2014-06-13

Remove signon-ui provides

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:127
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/127/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/20
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/20
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/20/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/20

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/127/rebuild

review: Approve (continuous-integration)

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

128. By Alberto Mardegan on 2014-07-02

Merge from trunk

129. By Alberto Mardegan on 2014-07-02

Implement account reauthentication and reauthorization

The need for a user interaction might arise at any time, depending on the remote service's policy. It will typically happen when an access token expires, or when an application requests new permissions or changes its key.
In order not to disrupt the user's activity, we preliminary implement this as a snap decision (as was suggested in https://docs.google.com/a/canonical.com/document/d/1puQ9Z0yKqzsQ1VQ1OOBkxgp78iWGnAhAkFXWJFTWIrE/edit#heading=h.topn0ejru38u). However, since design has not yet come up with a definitive approach, we keep the UI strings untranslated since they are not final.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:129
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-ci/129/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/22
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-armhf-ci/22/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-online-accounts-utopic-i386-ci/22

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-online-accounts-ci/129/rebuild

review: Approve (continuous-integration)

[David Barth (dbarth)]

review: Approve

[lp:~mardy/ubuntu-system-settings-online-accounts/master]

130. By Alberto Mardegan on 2014-08-08

From trunk

* Add forgotten test-dep on ubuntu-ui-toolkit-autopilot.
[ Leo Arias ]
* Refactored the autopilot tests to use the page object pattern. Added
  the method go to add account to be used in UX tests.
[ Michał Sawicz ]
* New icon from suru theme.

131. By Alberto Mardegan on 2014-08-13

Move the UI into a separate process

Introduce online-accounts-service as a UI-less DBus service which acts as a
dispatcher for authentication and authorization requests; the requests
themselves are processed by a subprocess, online-accounts-ui, of which multiple
instances can exists (each instance having single window).

This is the first step towards implementing trust session support.

132. By Alberto Mardegan on 2014-08-14

This branch moves the OA settings back into the main settings application, as an inline plugin. This should help with the overall UX, and in particular some annoying bugs ("black window", etc.)

The functional scope covers:
- listing online accounts
- changing apps permissions for an account
- adding a new online account
- removing an online account

The branch has currently some limitations:
- only support OAuth providers
- the system-widw OAuth provider path is hardcoded
- doesn't support providers installed in the home directory

The limitations should be easy to lift once the general logic is reviewed.

133. By Alberto Mardegan on 2014-08-14

Support Mir prompt sessions

134. By Alberto Mardegan on 2014-08-18

Avoid clicking multiple times

135. By Alberto Mardegan on 2014-08-18

Make the Mir dependency optional

Mir is not yet available for all architectures.

=== modified file '.bzrignore'
--- .bzrignore	2014-06-05 13:28:30 +0000
+++ .bzrignore	2014-08-18 13:33:35 +0000
@@ -31,18 +31,20 @@
 /debian/*.substvars
 /plugins/example/libexample.so*
 /po/*.mo
-/src/com.ubuntu.OnlineAccountsUi.service
-/src/module/OnlineAccountsPlugin.pc
-/src/module/libOnlineAccountsPlugin.so*
-/src/module/qmldir
-/src/online-accounts-ui.desktop
-/src/online-accounts-ui
+/online-accounts-service/com.ubuntu.OnlineAccountsUi.service
+/online-accounts-service/online-accounts-service
+/online-accounts-ui/module/OnlineAccountsPlugin.pc
+/online-accounts-ui/module/libOnlineAccountsPlugin.so*
+/online-accounts-ui/module/qmldir
+/online-accounts-ui/online-accounts-ui.desktop
+/online-accounts-ui/online-accounts-ui
 /tests/click-hooks/tst_online_accounts_hooks
 /tests/client/tst_client
 /tests/client/tst_qml_client
+/tests/online-accounts-service/tst_inactivity_timer
+/tests/online-accounts-service/tst_service
 /tests/online-accounts-ui/qml/tst_online_accounts_qml
 /tests/online-accounts-ui/tst_access_model
 /tests/online-accounts-ui/tst_application_manager
-/tests/online-accounts-ui/tst_inactivity_timer
 /tests/online-accounts-ui/tst_notification
-/tests/online-accounts-ui/tst_service
+/tests/online-accounts-ui/tst_signonui_request
 
=== modified file 'client/OnlineAccountsClient/OnlineAccountsClient.pro'
--- client/OnlineAccountsClient/OnlineAccountsClient.pro	2014-03-19 12:14:14 +0000
+++ client/OnlineAccountsClient/OnlineAccountsClient.pro	2014-08-18 13:33:35 +0000
@@ -25,10 +25,10 @@
 INCLUDEPATH += \
     $${TOP_SRC_DIR}
 
-ONLINE_ACCOUNTS_UI_SRC = $${TOP_SRC_DIR}/src
+ONLINE_ACCOUNTS_SERVICE_SRC = $${TOP_SRC_DIR}/online-accounts-service
 
 DBUS_INTERFACES += \
-    $${ONLINE_ACCOUNTS_UI_SRC}/com.ubuntu.OnlineAccountsUi.xml
+    $${ONLINE_ACCOUNTS_SERVICE_SRC}/com.ubuntu.OnlineAccountsUi.xml
 
 SOURCES += \
     setup.cpp
 
=== modified file 'client/OnlineAccountsClient/setup.cpp'
--- client/OnlineAccountsClient/setup.cpp	2014-05-30 08:09:02 +0000
+++ client/OnlineAccountsClient/setup.cpp	2014-08-18 13:33:35 +0000
@@ -20,9 +20,9 @@
  * <http://www.gnu.org/licenses/>.
  */
 
+#include "online-accounts-ui/globals.h"
 #include "onlineaccountsui_interface.h"
 #include "setup.h"
-#include "src/globals.h"
 
 #include <QDBusConnection>
 #include <QDBusPendingCallWatcher>
@@ -76,6 +76,8 @@
 {
     QVariantMap options;
 
+    options.insert(OAU_KEY_PID, uint(getpid()));
+
     QWindow *window = clientWindow();
     if (window) {
         options.insert(OAU_KEY_WINDOW_ID, window->winId());
 
=== modified file 'common-project-config.pri'
--- common-project-config.pri	2013-08-06 15:06:54 +0000
+++ common-project-config.pri	2014-08-18 13:33:35 +0000
@@ -47,3 +47,6 @@
 PLUGIN_MODULE_DIR = $$system("pkg-config --define-variable=prefix=$${INSTALL_PREFIX} --variable plugin_module_dir SystemSettings")
 PLUGIN_QML_DIR = $$system("pkg-config --define-variable=prefix=$${INSTALL_PREFIX} --variable plugin_qml_dir SystemSettings")
 PLUGIN_PRIVATE_MODULE_DIR = $$system("pkg-config --define-variable=prefix=$${INSTALL_PREFIX} --variable plugin_private_module_dir SystemSettings")
+
+I18N_DOMAIN="ubuntu-system-settings-online-accounts"
+SIGNONUI_I18N_DOMAIN="signon-ui"
 
=== modified file 'debian/control'
--- debian/control	2014-06-04 12:00:43 +0000
+++ debian/control	2014-08-18 13:33:35 +0000
@@ -6,6 +6,7 @@
                pkg-config,
                python3:any,
                libaccounts-qt5-dev,
+               libmirclient-dev [!powerpc !ppc64 !ppc64el],
                libnotify-dev,
                libsignon-qt5-dev,
                libsystemsettings-dev (>= 0.1+13.10.20130806),
@@ -36,7 +37,6 @@
          qtdeclarative5-ubuntu-ui-toolkit-plugin | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles,
          signon-ui-service,
          ubuntu-system-settings
-Provides: signon-ui
 Description: Online Accounts setup for Ubuntu Touch
  Online Accounts setup utility for the Ubuntu Touch System Settings.
 
 
=== modified file 'debian/rules'
--- debian/rules	2014-06-06 08:10:04 +0000
+++ debian/rules	2014-08-18 13:33:35 +0000
@@ -8,6 +8,7 @@
 	dh_auto_configure -- \
 		LIBDIR=/usr/lib/$(DEB_HOST_MULTIARCH) \
 		"QMAKE_CXXFLAGS=$(CFLAGS)" \
+		CONFIG+=enable-mir \
 		CONFIG+=ubuntu-docs \
 		ubuntu-system-settings-online-accounts.pro
 
 
=== modified file 'debian/ubuntu-system-settings-online-accounts.install'
--- debian/ubuntu-system-settings-online-accounts.install	2014-06-04 09:59:37 +0000
+++ debian/ubuntu-system-settings-online-accounts.install	2014-08-18 13:33:35 +0000
@@ -1,4 +1,5 @@
 usr/bin/online-accounts-hooks
+usr/bin/online-accounts-service
 usr/bin/online-accounts-ui
 usr/lib/*/pkgconfig/OnlineAccountsPlugin.pc
 usr/lib/*/ubuntu-system-settings
 
=== added directory 'online-accounts-service'
=== renamed file 'src/com.canonical.indicators.webcredentials.xml' => 'online-accounts-service/com.canonical.indicators.webcredentials.xml'
=== renamed file 'src/com.ubuntu.OnlineAccountsUi.service.in' => 'online-accounts-service/com.ubuntu.OnlineAccountsUi.service.in'
--- src/com.ubuntu.OnlineAccountsUi.service.in	2013-11-21 12:26:22 +0000
+++ online-accounts-service/com.ubuntu.OnlineAccountsUi.service.in	2014-08-18 13:33:35 +0000
@@ -1,3 +1,3 @@
 [D-BUS Service]
 Name=com.ubuntu.OnlineAccountsUi
-Exec=$${INSTALL_PREFIX}/bin/$${TARGET} --desktop_file_hint=$${desktop.path}/$${TARGET}.desktop
+Exec=$${INSTALL_PREFIX}/bin/$${TARGET}
 
=== renamed file 'src/com.ubuntu.OnlineAccountsUi.xml' => 'online-accounts-service/com.ubuntu.OnlineAccountsUi.xml'
=== renamed file 'src/inactivity-timer.cpp' => 'online-accounts-service/inactivity-timer.cpp'
=== renamed file 'src/inactivity-timer.h' => 'online-accounts-service/inactivity-timer.h'
=== renamed file 'src/indicator-service.cpp' => 'online-accounts-service/indicator-service.cpp'
=== renamed file 'src/indicator-service.h' => 'online-accounts-service/indicator-service.h'
=== added file 'online-accounts-service/main.cpp'
--- online-accounts-service/main.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-service/main.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "globals.h"
+#include "inactivity-timer.h"
+#include "indicator-service.h"
+#include "request-manager.h"
+#include "service.h"
+#include "signonui-service.h"
+
+#include <QCoreApplication>
+#include <QDBusConnection>
+#include <QProcessEnvironment>
+
+using namespace OnlineAccountsUi;
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+
+    /* read environment variables */
+    QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
+    if (environment.contains(QLatin1String("OAU_LOGGING_LEVEL"))) {
+        bool isOk;
+        int value = environment.value(
+            QLatin1String("OAU_LOGGING_LEVEL")).toInt(&isOk);
+        if (isOk)
+            setLoggingLevel(value);
+    }
+
+    /* default daemonTimeout to 5 seconds */
+    int daemonTimeout = 5;
+
+    /* override daemonTimeout if OAU_DAEMON_TIMEOUT is set */
+    if (environment.contains(QLatin1String("OAU_DAEMON_TIMEOUT"))) {
+        bool isOk;
+        int value = environment.value(
+            QLatin1String("OAU_DAEMON_TIMEOUT")).toInt(&isOk);
+        if (isOk)
+            daemonTimeout = value;
+    }
+
+    RequestManager *requestManager = new RequestManager();
+
+    Service *service = new Service();
+    QDBusConnection connection = QDBusConnection::sessionBus();
+    connection.registerService(OAU_SERVICE_NAME);
+    connection.registerObject(OAU_OBJECT_PATH, service);
+
+    SignOnUi::Service *signonuiService = new SignOnUi::Service();
+    connection.registerService(SIGNONUI_SERVICE_NAME);
+    connection.registerObject(SIGNONUI_OBJECT_PATH, signonuiService,
+                              QDBusConnection::ExportAllContents);
+
+    SignOnUi::IndicatorService *indicatorService =
+        new SignOnUi::IndicatorService();
+    connection.registerService(WEBCREDENTIALS_BUS_NAME);
+    connection.registerObject(WEBCREDENTIALS_OBJECT_PATH,
+                              indicatorService->serviceObject());
+
+
+    InactivityTimer *inactivityTimer = 0;
+    if (daemonTimeout > 0) {
+        inactivityTimer = new InactivityTimer(daemonTimeout * 1000);
+        inactivityTimer->watchObject(requestManager);
+        inactivityTimer->watchObject(indicatorService);
+        QObject::connect(inactivityTimer, SIGNAL(timeout()),
+                         &app, SLOT(quit()));
+    }
+
+    int ret = app.exec();
+
+    connection.unregisterService(WEBCREDENTIALS_BUS_NAME);
+    connection.unregisterObject(WEBCREDENTIALS_OBJECT_PATH);
+    delete indicatorService;
+
+    connection.unregisterService(SIGNONUI_SERVICE_NAME);
+    connection.unregisterObject(SIGNONUI_OBJECT_PATH);
+    delete signonuiService;
+
+    connection.unregisterService(OAU_SERVICE_NAME);
+    connection.unregisterObject(OAU_OBJECT_PATH);
+    delete service;
+
+    delete requestManager;
+
+    delete inactivityTimer;
+
+    return ret;
+}
+
 
=== added file 'online-accounts-service/mir-helper-stub.cpp'
--- online-accounts-service/mir-helper-stub.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-service/mir-helper-stub.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "mir-helper.h"
+
+using namespace OnlineAccountsUi;
+
+namespace OnlineAccountsUi {
+
+static MirHelper *m_instance = 0;
+
+} // namespace
+
+PromptSession::PromptSession(PromptSessionPrivate *priv):
+    d_ptr(priv)
+{
+}
+
+PromptSession::~PromptSession()
+{
+}
+
+QString PromptSession::requestSocket()
+{
+    return QString();
+}
+
+MirHelper::MirHelper(QObject *parent):
+    QObject(parent),
+    d_ptr(0)
+{
+}
+
+MirHelper::~MirHelper()
+{
+    m_instance = 0;
+}
+
+MirHelper *MirHelper::instance()
+{
+    if (!m_instance) {
+        m_instance = new MirHelper;
+    }
+    return m_instance;
+}
+
+PromptSession *MirHelper::createPromptSession(pid_t initiatorPid)
+{
+    Q_UNUSED(initiatorPid);
+    return 0;
+}
 
=== added file 'online-accounts-service/mir-helper.cpp'
--- online-accounts-service/mir-helper.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-service/mir-helper.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "mir-helper.h"
+
+#include <mir_toolkit/mir_client_library.h>
+#include <mir_toolkit/mir_prompt_session.h>
+
+#include <QList>
+#include <QStandardPaths>
+
+using namespace OnlineAccountsUi;
+
+namespace OnlineAccountsUi {
+
+static MirHelper *m_instance = 0;
+
+class PromptSessionPrivate
+{
+public:
+    inline PromptSessionPrivate(MirPromptSession *session);
+    inline ~PromptSessionPrivate();
+
+    MirPromptSession *m_mirSession;
+    QList<int> m_fds;
+    mutable PromptSession *q_ptr;
+};
+
+class MirHelperPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(MirHelper)
+
+public:
+    inline MirHelperPrivate(MirHelper *helper);
+    inline ~MirHelperPrivate();
+
+    PromptSession *createPromptSession(pid_t initiatorPid);
+
+private:
+    friend class PromptSession;
+    MirConnection *m_connection;
+    QList<PromptSession*> m_sessions;
+    mutable MirHelper *q_ptr;
+};
+
+} // namespace
+
+PromptSessionPrivate::PromptSessionPrivate(MirPromptSession *session):
+    m_mirSession(session)
+{
+}
+
+PromptSessionPrivate::~PromptSessionPrivate()
+{
+    mir_prompt_session_release_sync(m_mirSession);
+    m_mirSession = 0;
+}
+
+PromptSession::PromptSession(PromptSessionPrivate *priv):
+    d_ptr(priv)
+{
+    MirHelperPrivate *helperPrivate = MirHelper::instance()->d_ptr;
+    helperPrivate->m_sessions.append(this);
+}
+
+PromptSession::~PromptSession()
+{
+    MirHelperPrivate *helperPrivate = MirHelper::instance()->d_ptr;
+    helperPrivate->m_sessions.removeOne(this);
+    delete d_ptr;
+}
+
+static void client_fd_callback(MirPromptSession *, size_t count,
+                               int const *fds, void *context)
+{
+    PromptSessionPrivate *priv = (PromptSessionPrivate *)context;
+    for (size_t i = 0; i < count; i++) {
+        priv->m_fds.append(fds[i]);
+    }
+}
+
+QString PromptSession::requestSocket()
+{
+    Q_D(PromptSession);
+
+    d->m_fds.clear();
+    mir_wait_for(mir_prompt_session_new_fds_for_prompt_providers(
+        d->m_mirSession, 1, client_fd_callback, d));
+    if (!d->m_fds.isEmpty()) {
+        return QString("fd://%1").arg(d->m_fds[0]);
+    } else {
+        return QString();
+    }
+}
+
+MirHelperPrivate::MirHelperPrivate(MirHelper *helper):
+    QObject(helper),
+    q_ptr(helper)
+{
+    QString mirSocket =
+        QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation) +
+        "/mir_socket_trusted";
+    m_connection = mir_connect_sync(mirSocket.toUtf8().constData(),
+                                    "online-accounts-service");
+    if (Q_UNLIKELY(!mir_connection_is_valid(m_connection))) {
+        qWarning() << "Invalid Mir connection:" <<
+            mir_connection_get_error_message(m_connection);
+        return;
+    }
+}
+
+MirHelperPrivate::~MirHelperPrivate()
+{
+    if (m_connection) {
+        mir_connection_release(m_connection);
+        m_connection = 0;
+    }
+}
+
+static void session_event_callback(MirPromptSession *,
+                                   MirPromptSessionState state,
+                                   void *)
+{
+    DEBUG() << "Prompt Session state updated to" << state;
+}
+
+
+PromptSession *MirHelperPrivate::createPromptSession(pid_t initiatorPid)
+{
+    if (Q_UNLIKELY(!m_connection)) return 0;
+
+    MirPromptSession *mirSession =
+        mir_connection_create_prompt_session_sync(m_connection,
+                                                  initiatorPid,
+                                                  session_event_callback,
+                                                  this);
+    if (!mirSession) return 0;
+
+    if (Q_UNLIKELY(!mir_prompt_session_is_valid(mirSession))) {
+        qWarning() << "Invalid prompt session:" <<
+            mir_prompt_session_error_message(mirSession);
+        return 0;
+    }
+
+    return new PromptSession(new PromptSessionPrivate(mirSession));
+}
+
+MirHelper::MirHelper(QObject *parent):
+    QObject(parent),
+    d_ptr(new MirHelperPrivate(this))
+{
+}
+
+MirHelper::~MirHelper()
+{
+    m_instance = 0;
+}
+
+MirHelper *MirHelper::instance()
+{
+    if (!m_instance) {
+        m_instance = new MirHelper;
+    }
+    return m_instance;
+}
+
+PromptSession *MirHelper::createPromptSession(pid_t initiatorPid)
+{
+    Q_D(MirHelper);
+    return d->createPromptSession(initiatorPid);
+}
+
+#include "mir-helper.moc"
 
=== added file 'online-accounts-service/mir-helper.h'
--- online-accounts-service/mir-helper.h	1970-01-01 00:00:00 +0000
+++ online-accounts-service/mir-helper.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OAU_MIR_HELPER_H
+#define OAU_MIR_HELPER_H
+
+#include <QObject>
+
+namespace OnlineAccountsUi {
+
+class PromptSessionPrivate;
+class MirHelperPrivate;
+
+class PromptSession
+{
+public:
+    ~PromptSession();
+
+    QString requestSocket();
+
+private:
+    explicit PromptSession(PromptSessionPrivate *priv);
+
+private:
+    friend class MirHelperPrivate;
+    PromptSessionPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(PromptSession)
+};
+
+class MirHelper: public QObject
+{
+    Q_OBJECT
+
+public:
+    static MirHelper *instance();
+
+    PromptSession *createPromptSession(pid_t initiatorPid);
+
+private:
+    explicit MirHelper(QObject *parent = 0);
+    ~MirHelper();
+
+private:
+    friend class PromptSession;
+    MirHelperPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(MirHelper)
+};
+
+} // namespace
+
+#endif // OAU_MIR_HELPER_H
 
=== added file 'online-accounts-service/online-accounts-service.pro'
--- online-accounts-service/online-accounts-service.pro	1970-01-01 00:00:00 +0000
+++ online-accounts-service/online-accounts-service.pro	2014-08-18 13:33:35 +0000
@@ -0,0 +1,82 @@
+include(../common-project-config.pri)
+include($${TOP_SRC_DIR}/common-vars.pri)
+
+TEMPLATE = app
+TARGET = online-accounts-service
+
+CONFIG += \
+    link_pkgconfig \
+    no_keywords \
+    qt
+
+QT += \
+    dbus \
+    network
+
+PKGCONFIG += \
+    libnotify \
+    libsignon-qt5 \
+    signon-plugins-common
+
+
+CONFIG(enable-mir) : system(pkg-config --exists mirclient) {
+    PKGCONFIG += mirclient
+    SOURCES += mir-helper.cpp
+} else {
+    SOURCES += mir-helper-stub.cpp
+}
+
+DBUS_ADAPTORS += \
+    com.ubuntu.OnlineAccountsUi.xml
+
+DEFINES += \
+    DEBUG_ENABLED \
+    SIGNONUI_I18N_DOMAIN=\\\"$${SIGNONUI_I18N_DOMAIN}\\\"
+
+COMMON_SRC = ../online-accounts-ui
+
+INCLUDEPATH += \
+    $${COMMON_SRC}
+
+SOURCES += \
+    $${COMMON_SRC}/debug.cpp \
+    $${COMMON_SRC}/i18n.cpp \
+    $${COMMON_SRC}/ipc.cpp \
+    $${COMMON_SRC}/notification.cpp \
+    inactivity-timer.cpp \
+    indicator-service.cpp \
+    main.cpp \
+    reauthenticator.cpp \
+    request.cpp \
+    request-manager.cpp \
+    service.cpp \
+    signonui-service.cpp \
+    ui-proxy.cpp
+
+HEADERS += \
+    $${COMMON_SRC}/debug.h \
+    $${COMMON_SRC}/i18n.h \
+    $${COMMON_SRC}/ipc.h \
+    $${COMMON_SRC}/notification.h \
+    inactivity-timer.h \
+    indicator-service.h \
+    mir-helper.h \
+    reauthenticator.h \
+    request.h \
+    request-manager.h \
+    service.h \
+    signonui-service.h \
+    ui-proxy.h
+
+QMAKE_SUBSTITUTES += \
+    com.ubuntu.OnlineAccountsUi.service.in
+
+DBUS_ADAPTORS += \
+    com.canonical.indicators.webcredentials.xml
+
+service.path = $${INSTALL_PREFIX}/share/dbus-1/services
+service.files = \
+    com.ubuntu.OnlineAccountsUi.service
+INSTALLS += service
+
+include($${TOP_SRC_DIR}/common-installs-config.pri)
 
=== renamed file 'src/reauthenticator.cpp' => 'online-accounts-service/reauthenticator.cpp'
=== renamed file 'src/reauthenticator.h' => 'online-accounts-service/reauthenticator.h'
=== renamed file 'src/request-manager.cpp' => 'online-accounts-service/request-manager.cpp'
--- src/request-manager.cpp	2014-04-29 12:11:55 +0000
+++ online-accounts-service/request-manager.cpp	2014-08-18 13:33:35 +0000
@@ -19,8 +19,10 @@
  */
 
 #include "debug.h"
+#include "globals.h"
 #include "request.h"
 #include "request-manager.h"
+#include "ui-proxy.h"
 
 #include <QQueue>
 
@@ -41,17 +43,19 @@
     RequestManagerPrivate(RequestManager *service);
     ~RequestManagerPrivate();
 
-    RequestQueue &queueForWindowId(WId windowId);
+    RequestQueue &queueForWindowId(quint64 windowId);
     void enqueue(Request *request);
     void runQueue(RequestQueue &queue);
 
 private Q_SLOTS:
     void onRequestCompleted();
+    void onProxyFinished();
 
 private:
     mutable RequestManager *q_ptr;
     /* each window Id has a different queue */
-    QMap<WId,RequestQueue> m_requests;
+    QMap<quint64,RequestQueue> m_requests;
+    QList<UiProxy*> m_proxies;
 };
 
 } // namespace
@@ -66,7 +70,7 @@
 {
 }
 
-RequestQueue &RequestManagerPrivate::queueForWindowId(WId windowId)
+RequestQueue &RequestManagerPrivate::queueForWindowId(quint64 windowId)
 {
     if (!m_requests.contains(windowId)) {
         RequestQueue queue;
@@ -78,9 +82,20 @@
 void RequestManagerPrivate::enqueue(Request *request)
 {
     Q_Q(RequestManager);
+
+    /* First, see if any of the existing proxies can handle this request */
+    Q_FOREACH(UiProxy *proxy, m_proxies) {
+        if (proxy->hasHandlerFor(request->parameters())) {
+            QObject::connect(request, SIGNAL(completed()),
+                             request, SLOT(deleteLater()));
+            proxy->handleRequest(request);
+            return;
+        }
+    }
+
     bool wasIdle = q->isIdle();
 
-    WId windowId = request->windowId();
+    quint64 windowId = request->windowId();
 
     RequestQueue &queue = queueForWindowId(windowId);
     queue.enqueue(request);
@@ -102,9 +117,20 @@
         return; // Nothing to do
     }
 
+    pid_t clientPid = (request->interface() == OAU_INTERFACE) ?
+        request->parameters().value(OAU_KEY_PID, 0).toUInt() : 0;
+    UiProxy *proxy = new UiProxy(clientPid, this);
+    if (Q_UNLIKELY(!proxy->init())) {
+        qWarning() << "UiProxy initialization failed!";
+        runQueue(queue);
+        return;
+    }
     QObject::connect(request, SIGNAL(completed()),
                      this, SLOT(onRequestCompleted()));
-    request->start();
+    QObject::connect(proxy, SIGNAL(finished()),
+                     this, SLOT(onProxyFinished()));
+    m_proxies.append(proxy);
+    proxy->handleRequest(request);
 }
 
 void RequestManagerPrivate::onRequestCompleted()
@@ -112,7 +138,7 @@
     Q_Q(RequestManager);
 
     Request *request = qobject_cast<Request*>(sender());
-    WId windowId = request->windowId();
+    quint64 windowId = request->windowId();
 
     RequestQueue &queue = queueForWindowId(windowId);
     if (request != queue.head()) {
@@ -135,6 +161,16 @@
     }
 }
 
+void RequestManagerPrivate::onProxyFinished()
+{
+    Q_Q(RequestManager);
+
+    UiProxy *proxy = qobject_cast<UiProxy*>(sender());
+    m_proxies.removeOne(proxy);
+
+    proxy->deleteLater();
+}
+
 RequestManager::RequestManager(QObject *parent):
     QObject(parent),
     d_ptr(new RequestManagerPrivate(this))
 
=== renamed file 'src/request-manager.h' => 'online-accounts-service/request-manager.h'
--- src/request-manager.h	2014-04-29 12:11:55 +0000
+++ online-accounts-service/request-manager.h	2014-08-18 13:33:35 +0000
@@ -27,8 +27,9 @@
 namespace OnlineAccountsUi {
 
 class Request;
+class UiProxy;
+
 class RequestManagerPrivate;
-
 class RequestManager: public QObject
 {
     Q_OBJECT
@@ -41,6 +42,7 @@
     static RequestManager *instance();
 
     void enqueue(Request *request);
+    UiProxy *findMatching(const QVariantMap &parameters);
 
     bool isIdle() const;
 
 
=== added file 'online-accounts-service/request.cpp'
--- online-accounts-service/request.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-service/request.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "globals.h"
+#include "request.h"
+
+using namespace OnlineAccountsUi;
+
+static bool mapIsSuperset(const QVariantMap &test, const QVariantMap &set)
+{
+    QMapIterator<QString, QVariant> it(set);
+    while (it.hasNext()) {
+        it.next();
+        if (test.value(it.key()) != it.value()) return false;
+    }
+
+    return true;
+}
+
+namespace OnlineAccountsUi {
+
+static QList<Request *> allRequests;
+
+class RequestPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(Request)
+
+public:
+    RequestPrivate(const QDBusConnection &connection,
+                   const QDBusMessage &message,
+                   const QVariantMap &parameters,
+                   Request *request);
+    ~RequestPrivate();
+
+    quint64 windowId() const {
+        return m_parameters[OAU_KEY_WINDOW_ID].toUInt();
+    }
+
+private:
+    QString findClientApparmorProfile();
+
+private:
+    mutable Request *q_ptr;
+    QDBusConnection m_connection;
+    QDBusMessage m_message;
+    QVariantMap m_parameters;
+    QString m_clientApparmorProfile;
+    bool m_inProgress;
+};
+
+} // namespace
+
+RequestPrivate::RequestPrivate(const QDBusConnection &connection,
+                               const QDBusMessage &message,
+                               const QVariantMap &parameters,
+                               Request *request):
+    QObject(request),
+    q_ptr(request),
+    m_connection(connection),
+    m_message(message),
+    m_parameters(parameters),
+    m_inProgress(false)
+{
+    m_clientApparmorProfile = findClientApparmorProfile();
+}
+
+RequestPrivate::~RequestPrivate()
+{
+}
+
+QString RequestPrivate::findClientApparmorProfile()
+{
+    QString uniqueConnectionId = m_message.service();
+    /* This is mainly for unit tests: real messages on the session bus always
+     * have a service name. */
+    if (uniqueConnectionId.isEmpty()) return QString();
+
+    QString appId;
+
+    QDBusMessage msg =
+        QDBusMessage::createMethodCall("org.freedesktop.DBus",
+                                       "/org/freedesktop/DBus",
+                                       "org.freedesktop.DBus",
+                                       "GetConnectionAppArmorSecurityContext");
+    QVariantList args;
+    args << uniqueConnectionId;
+    msg.setArguments(args);
+    QDBusMessage reply = QDBusConnection::sessionBus().call(msg, QDBus::Block);
+    if (reply.type() == QDBusMessage::ReplyMessage) {
+        appId = reply.arguments().value(0, QString()).toString();
+        DEBUG() << "App ID:" << appId;
+    } else {
+        qWarning() << "Error getting app ID:" << reply.errorName() <<
+            reply.errorMessage();
+    }
+    return appId;
+}
+
+Request::Request(const QDBusConnection &connection,
+                 const QDBusMessage &message,
+                 const QVariantMap &parameters,
+                 QObject *parent):
+    QObject(parent),
+    d_ptr(new RequestPrivate(connection, message, parameters, this))
+{
+    allRequests.append(this);
+}
+
+Request::~Request()
+{
+    allRequests.removeOne(this);
+}
+
+Request *Request::find(const QVariantMap &match)
+{
+    Q_FOREACH(Request *r, allRequests) {
+        if (mapIsSuperset(r->parameters(), match)) {
+            return r;
+        }
+    }
+
+    return 0;
+}
+
+quint64 Request::windowId() const
+{
+    Q_D(const Request);
+    return d->windowId();
+}
+
+void Request::setInProgress(bool inProgress)
+{
+    Q_D(Request);
+    d->m_inProgress = inProgress;
+}
+
+bool Request::isInProgress() const
+{
+    Q_D(const Request);
+    return d->m_inProgress;
+}
+
+const QVariantMap &Request::parameters() const
+{
+    Q_D(const Request);
+    return d->m_parameters;
+}
+
+QString Request::clientApparmorProfile() const
+{
+    Q_D(const Request);
+    return d->m_clientApparmorProfile;
+}
+
+QString Request::interface() const {
+    Q_D(const Request);
+    return d->m_message.interface();
+}
+
+void Request::cancel()
+{
+    setCanceled();
+}
+
+void Request::fail(const QString &name, const QString &message)
+{
+    Q_D(Request);
+    QDBusMessage reply = d->m_message.createErrorReply(name, message);
+    d->m_connection.send(reply);
+
+    Q_EMIT completed();
+}
+
+void Request::setCanceled()
+{
+    Q_D(Request);
+    if (d->m_inProgress) {
+        fail(OAU_ERROR_USER_CANCELED, QStringLiteral("Canceled"));
+        d->m_inProgress = false;
+    }
+}
+
+void Request::setResult(const QVariantMap &result)
+{
+    Q_D(Request);
+    if (d->m_inProgress) {
+        QDBusMessage reply = d->m_message.createReply(result);
+        d->m_connection.send(reply);
+
+        Q_EMIT completed();
+        d->m_inProgress = false;
+    }
+}
+
+#include "request.moc"
 
=== added file 'online-accounts-service/request.h'
--- online-accounts-service/request.h	1970-01-01 00:00:00 +0000
+++ online-accounts-service/request.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OAU_REQUEST_H
+#define OAU_REQUEST_H
+
+#include <QDBusConnection>
+#include <QDBusMessage>
+#include <QObject>
+#include <QVariantMap>
+
+namespace OnlineAccountsUi {
+
+class RequestPrivate;
+class Request: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit Request(const QDBusConnection &connection,
+                     const QDBusMessage &message,
+                     const QVariantMap &parameters,
+                     QObject *parent = 0);
+    ~Request();
+
+    static Request *find(const QVariantMap &match);
+
+    quint64 windowId() const;
+    void setInProgress(bool inProgress);
+    bool isInProgress() const;
+    const QVariantMap &parameters() const;
+    QString clientApparmorProfile() const;
+    QString interface() const;
+
+public Q_SLOTS:
+    void cancel();
+
+Q_SIGNALS:
+    void completed();
+
+public Q_SLOTS:
+    void fail(const QString &name, const QString &message);
+    void setCanceled();
+    void setResult(const QVariantMap &result);
+
+private:
+    RequestPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(Request)
+};
+
+} // namespace
+
+#endif // OAU_REQUEST_H
 
=== renamed file 'src/service.cpp' => 'online-accounts-service/service.cpp'
--- src/service.cpp	2014-05-30 08:09:02 +0000
+++ online-accounts-service/service.cpp	2014-08-18 13:33:35 +0000
@@ -44,17 +44,9 @@
     /* The following line tells QtDBus not to generate a reply now */
     setDelayedReply(true);
 
-    Request *request = Request::newRequest(connection(),
-                                           message(),
-                                           options,
-                                           this);
-    if (request) {
-        RequestManager *manager = RequestManager::instance();
-        manager->enqueue(request);
-    } else {
-        sendErrorReply(OAU_ERROR_INVALID_PARAMETERS,
-                       QStringLiteral("Invalid request"));
-    }
+    Request *request = new Request(connection(), message(), options, this);
+    RequestManager *manager = RequestManager::instance();
+    manager->enqueue(request);
 
     return QVariantMap();
 }
 
=== renamed file 'src/service.h' => 'online-accounts-service/service.h'
=== renamed file 'src/signonui-service.cpp' => 'online-accounts-service/signonui-service.cpp'
--- src/signonui-service.cpp	2014-04-29 14:34:44 +0000
+++ online-accounts-service/signonui-service.cpp	2014-08-18 13:33:35 +0000
@@ -20,14 +20,12 @@
 
 #include "debug.h"
 #include "request.h"
-#include "request-handler.h"
 #include "request-manager.h"
-#include "signonui-request.h"
 #include "signonui-service.h"
-#include "browser-request.h"
 
 #include <QDBusArgument>
-#include <QtQml>
+#include <QDir>
+#include <QStandardPaths>
 #include <SignOn/uisessiondata_priv.h>
 
 using namespace SignOnUi;
@@ -77,6 +75,8 @@
     void cancelUiRequest(const QString &requestId);
     void removeIdentityData(quint32 id);
 
+    static QString rootDirForIdentity(quint32 id);
+
 private:
     mutable Service *q_ptr;
 };
@@ -106,20 +106,24 @@
     }
 }
 
+QString ServicePrivate::rootDirForIdentity(quint32 id)
+{
+    QString cachePath =
+        QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+    return cachePath + QString("/id-%1").arg(id);
+}
+
 void ServicePrivate::removeIdentityData(quint32 id)
 {
     /* Remove any data associated with the given identity. */
-
-    /* The BrowserRequest class creates a directory to store the cookies */
-    BrowserRequest::removeIdentityData(id);
+    QDir rootDir(ServicePrivate::rootDirForIdentity(id));
+    rootDir.removeRecursively();
 }
 
 Service::Service(QObject *parent):
     QObject(parent),
     d_ptr(new ServicePrivate(this))
 {
-    qmlRegisterType<SignOnUi::RequestHandler>("Ubuntu.OnlineAccounts.Plugin",
-                                              1, 0, "RequestHandler");
 }
 
 Service::~Service()
@@ -135,29 +139,12 @@
     setDelayedReply(true);
 
     OnlineAccountsUi::Request *request =
-        OnlineAccountsUi::Request::newRequest(connection(),
-                                              message(),
-                                              cleanParameters,
-                                              this);
-
-    /* Check if a RequestHandler has been setup to handle this request. If
-     * so, bing the request object to the handler and start the request
-     * immediately. */
-    SignOnUi::Request *signonRequest =
-        qobject_cast<SignOnUi::Request*>(request);
-    Q_ASSERT(signonRequest != 0);
-
-    RequestHandler *handler = RequestHandler::findMatching(cleanParameters);
-    if (handler != 0) {
-        DEBUG() << "Found RequestHandler!";
-        signonRequest->setHandler(handler);
-        QObject::connect(signonRequest, SIGNAL(completed()),
-                         signonRequest, SLOT(deleteLater()));
-        signonRequest->start();
-    } else {
-        // proceed normally
-        OnlineAccountsUi::RequestManager::instance()->enqueue(request);
-    }
+        new OnlineAccountsUi::Request(connection(),
+                                      message(),
+                                      cleanParameters,
+                                      this);
+
+    OnlineAccountsUi::RequestManager::instance()->enqueue(request);
 
     return QVariantMap();
 }
@@ -165,7 +152,6 @@
 QVariantMap Service::refreshDialog(const QVariantMap &newParameters)
 {
     QVariantMap cleanParameters = expandDBusArguments(newParameters);
-    QString requestId = Request::id(cleanParameters);
     // TODO find the request and update it
 
     /* The following line tells QtDBus not to generate a reply now */
 
=== renamed file 'src/signonui-service.h' => 'online-accounts-service/signonui-service.h'
=== added file 'online-accounts-service/ui-proxy.cpp'
--- online-accounts-service/ui-proxy.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-service/ui-proxy.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "ipc.h"
+#include "mir-helper.h"
+#include "request.h"
+#include "ui-proxy.h"
+
+#include <QDir>
+#include <QFileInfo>
+#include <QLocalServer>
+#include <QLocalSocket>
+#include <QProcess>
+#include <QProcessEnvironment>
+#include <QStandardPaths>
+#include <SignOn/uisessiondata_priv.h>
+
+using namespace OnlineAccountsUi;
+
+static int socketCounter = 1;
+
+namespace OnlineAccountsUi {
+
+class UiProxyPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(UiProxy)
+
+public:
+    inline UiProxyPrivate(pid_t clientPid, UiProxy *pluginProxy);
+    inline ~UiProxyPrivate();
+
+    bool setupSocket();
+    bool init();
+    void sendOperation(const QVariantMap &data);
+    void sendRequest(int requestId, Request *request);
+    void setupPromptSession();
+
+private Q_SLOTS:
+    void onNewConnection();
+    void onDataReady(QByteArray &data);
+    void onRequestCompleted();
+
+private:
+    QProcess m_process;
+    QLocalServer m_server;
+    QLocalSocket *m_socket;
+    OnlineAccountsUi::Ipc m_ipc;
+    int m_nextRequestId;
+    QMap<int,Request*> m_requests;
+    QStringList m_handlers;
+    pid_t m_clientPid;
+    PromptSession *m_promptSession;
+    mutable UiProxy *q_ptr;
+};
+
+} // namespace
+
+UiProxyPrivate::UiProxyPrivate(pid_t clientPid, UiProxy *uiProxy):
+    QObject(uiProxy),
+    m_socket(0),
+    m_nextRequestId(0),
+    m_clientPid(clientPid),
+    m_promptSession(0),
+    q_ptr(uiProxy)
+{
+    QObject::connect(&m_server, SIGNAL(newConnection()),
+                     this, SLOT(onNewConnection()));
+    QObject::connect(&m_ipc, SIGNAL(dataReady(QByteArray &)),
+                     this, SLOT(onDataReady(QByteArray &)));
+    m_process.setProcessChannelMode(QProcess::ForwardedChannels);
+}
+
+UiProxyPrivate::~UiProxyPrivate()
+{
+    /* Cancel all requests */
+    Q_FOREACH(Request *request, m_requests) {
+        request->cancel();
+    }
+
+    delete m_promptSession;
+
+    if (m_socket) {
+        m_socket->abort();
+        delete m_socket;
+    }
+    m_server.close();
+}
+
+void UiProxyPrivate::sendOperation(const QVariantMap &data)
+{
+    QByteArray ba;
+    QDataStream stream(&ba, QIODevice::WriteOnly);
+    stream << data;
+    m_ipc.write(ba);
+}
+
+void UiProxyPrivate::onNewConnection()
+{
+    Q_Q(UiProxy);
+
+    QLocalSocket *socket = m_server.nextPendingConnection();
+    if (Q_UNLIKELY(socket == 0)) return;
+
+    if (Q_UNLIKELY(m_socket != 0)) {
+        qWarning() << "A socket is already active!";
+        socket->deleteLater();
+        return;
+    }
+
+    m_socket = socket;
+    QObject::connect(socket, SIGNAL(disconnected()),
+                     q, SIGNAL(finished()));
+    m_ipc.setChannels(socket, socket);
+    m_server.close(); // stop listening
+
+    /* Execute any pending requests */
+    QMapIterator<int, Request*> it(m_requests);
+    while (it.hasNext()) {
+        it.next();
+        sendRequest(it.key(), it.value());
+    }
+}
+
+void UiProxyPrivate::onDataReady(QByteArray &data)
+{
+    Q_Q(UiProxy);
+
+    QVariantMap map;
+    QDataStream stream(&data, QIODevice::ReadOnly);
+    stream >> map;
+
+    DEBUG() << map;
+
+    int requestId = map.value(OAU_OPERATION_ID, -1).toInt();
+    Request *request = m_requests.value(requestId, 0);
+
+    QString code = map.value(OAU_OPERATION_CODE).toString();
+    if (code == OAU_OPERATION_CODE_REQUEST_FINISHED) {
+        Q_ASSERT(request);
+        request->setResult(map.value(OAU_OPERATION_DATA).toMap());
+    } else if (code == OAU_OPERATION_CODE_REQUEST_FAILED) {
+        Q_ASSERT(request);
+        request->fail(map.value(OAU_OPERATION_ERROR_NAME).toString(),
+                      map.value(OAU_OPERATION_ERROR_MESSAGE).toString());
+    } else if (code == OAU_OPERATION_CODE_REGISTER_HANDLER) {
+        m_handlers.append(map.value(OAU_OPERATION_HANDLER_ID).toString());
+    } else {
+        qWarning() << "Invalid operation code: " << code;
+    }
+}
+
+bool UiProxyPrivate::setupSocket()
+{
+    QString runtimeDir =
+        QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
+    QDir socketDir(runtimeDir + "/online-accounts-ui");
+    if (!socketDir.exists()) socketDir.mkpath(".");
+
+    QString uniqueName = QString("ui-%1").arg(socketCounter++);
+
+    /* If the file exists, it's a stale file: online-accounts-ui is a single
+     * instance process, and the only one creating files in this directory. */
+    if (Q_UNLIKELY(socketDir.exists(uniqueName))) {
+        socketDir.remove(uniqueName);
+    }
+
+    /* Create the socket and set it into listen mode */
+    return m_server.listen(socketDir.filePath(uniqueName));
+}
+
+void UiProxyPrivate::setupPromptSession()
+{
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+    if (!env.value("QT_QPA_PLATFORM").startsWith("ubuntu")) return;
+
+    PromptSession *session =
+        MirHelper::instance()->createPromptSession(m_clientPid);
+    if (!session) return;
+
+    QString mirSocket = session->requestSocket();
+    if (mirSocket.isEmpty()) {
+        delete session;
+        return;
+    }
+
+    m_promptSession = session;
+
+    env.insert("MIR_SOCKET", mirSocket);
+    m_process.setProcessEnvironment(env);
+}
+
+bool UiProxyPrivate::init()
+{
+    if (Q_UNLIKELY(!setupSocket())) return false;
+
+    QStringList arguments;
+    /* the first argument is required to be the desktop file */
+    arguments.append("--desktop_file_hint=/usr/share/applications/online-accounts-ui.desktop");
+    arguments.append("--socket");
+    arguments.append(m_server.fullServerName());
+
+    if (m_clientPid) {
+        setupPromptSession();
+    }
+
+    m_process.start("/usr/bin/online-accounts-ui", arguments);
+    return m_process.waitForStarted();
+}
+
+void UiProxyPrivate::sendRequest(int requestId, Request *request)
+{
+    QVariantMap operation;
+    operation.insert(OAU_OPERATION_CODE, OAU_OPERATION_CODE_PROCESS);
+    operation.insert(OAU_OPERATION_ID, requestId);
+    operation.insert(OAU_OPERATION_DATA, request->parameters());
+    operation.insert(OAU_OPERATION_INTERFACE, request->interface());
+    operation.insert(OAU_OPERATION_CLIENT_PROFILE,
+                     request->clientApparmorProfile());
+    sendOperation(operation);
+}
+
+void UiProxyPrivate::onRequestCompleted()
+{
+    Request *request = qobject_cast<Request*>(sender());
+    int id = m_requests.key(request, -1);
+    if (id != -1) {
+        m_requests.remove(id);
+    }
+}
+
+UiProxy::UiProxy(pid_t clientPid, QObject *parent):
+    QObject(parent),
+    d_ptr(new UiProxyPrivate(clientPid, this))
+{
+}
+
+UiProxy::~UiProxy()
+{
+}
+
+bool UiProxy::init()
+{
+    Q_D(UiProxy);
+    return d->init();
+}
+
+void UiProxy::handleRequest(Request *request)
+{
+    Q_D(UiProxy);
+
+    int requestId = d->m_nextRequestId++;
+    d->m_requests.insert(requestId, request);
+    QObject::connect(request, SIGNAL(completed()),
+                     d, SLOT(onRequestCompleted()));
+    request->setInProgress(true);
+
+    if (d->m_socket && d->m_socket->isValid()) {
+        d->sendRequest(requestId, request);
+    }
+}
+
+bool UiProxy::hasHandlerFor(const QVariantMap &parameters)
+{
+    Q_D(UiProxy);
+
+    /* Find if there's any handlers expecting to handle the SignOnUi
+     * request having "parameters" as parameters.
+     * This is simply done by matching on the X-RequestHandler key (aka
+     * matchKey()), if present. We expect that account plugins add that field
+     * to their AuthSession requests which they want to handle themselves.
+     */
+    DEBUG() << parameters;
+    if (!parameters.contains(SSOUI_KEY_CLIENT_DATA)) return false;
+    QVariant variant = parameters[SSOUI_KEY_CLIENT_DATA];
+    QVariantMap clientData = variant.toMap();
+    QString matchId = clientData.value(OAU_REQUEST_MATCH_KEY).toString();
+    if (matchId.isEmpty()) return false;
+
+    return d->m_handlers.contains(matchId);
+}
+
+#include "ui-proxy.moc"
 
=== added file 'online-accounts-service/ui-proxy.h'
--- online-accounts-service/ui-proxy.h	1970-01-01 00:00:00 +0000
+++ online-accounts-service/ui-proxy.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OAU_UI_PROXY_H
+#define OAU_UI_PROXY_H
+
+#include <QObject>
+#include <QVariantMap>
+
+namespace OnlineAccountsUi {
+
+class Request;
+
+class UiProxyPrivate;
+class UiProxy: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit UiProxy(pid_t clientPid, QObject *parent = 0);
+    ~UiProxy();
+
+    bool init();
+    void handleRequest(Request *request);
+    bool hasHandlerFor(const QVariantMap &parameters);
+
+Q_SIGNALS:
+    void finished();
+
+private:
+    UiProxyPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(UiProxy)
+};
+
+} // namespace
+
+#endif // OAU_UI_PROXY_H
 
=== renamed directory 'src' => 'online-accounts-ui'
=== modified file 'online-accounts-ui/application-manager.cpp'
--- src/application-manager.cpp	2014-06-06 07:19:34 +0000
+++ online-accounts-ui/application-manager.cpp	2014-08-18 13:33:35 +0000
@@ -130,6 +130,16 @@
 
     if (Q_UNLIKELY(profile.isEmpty())) return QVariantMap();
 
+    /* Special case: when the applicationId is "system-settings", we don't
+     * require the existance of the .application file, because this request
+     * will always be about creating a new account. */
+    if (claimedAppId == "system-settings") {
+        QVariantMap app;
+        app.insert(QStringLiteral("id"), claimedAppId);
+        app.insert(QStringLiteral("profile"), profile);
+        return app;
+    }
+
     QString applicationId = claimedAppId;
     Accounts::Application application =
         AccountManager::instance()->application(applicationId);
 
=== modified file 'online-accounts-ui/browser-request.cpp'
--- src/browser-request.cpp	2014-04-29 14:34:44 +0000
+++ online-accounts-ui/browser-request.cpp	2014-08-18 13:33:35 +0000
@@ -28,6 +28,7 @@
 
 #include <QDir>
 #include <QQmlContext>
+#include <QQmlEngine>
 #include <QStandardPaths>
 #include <QTimer>
 #include <SignOn/uisessiondata_priv.h>
@@ -101,6 +102,7 @@
 
 BrowserRequestPrivate::~BrowserRequestPrivate()
 {
+    DEBUG();
     closeView();
     delete m_dialog;
 }
@@ -133,18 +135,9 @@
         QObject::connect(m_dialog, SIGNAL(finished(int)),
                          this, SLOT(onFinished()));
 
-        QUrl webview("qrc:/MainWindow.qml");
-        QDir qmlDir("/usr/share/signon-ui/qml");
-        if (qmlDir.exists())
-        {
-            QFileInfo qmlFile(qmlDir.absolutePath() + "/MainWindow.qml");
-            if (qmlFile.exists())
-                webview.setUrl(qmlFile.absoluteFilePath());
-        }
-
+        m_dialog->engine()->addImportPath(PLUGIN_PRIVATE_MODULE_DIR);
         m_dialog->rootContext()->setContextProperty("request", this);
-        m_dialog->rootContext()->setContextProperty("rootDir", m_rootDir);
-        m_dialog->setSource(webview);
+        m_dialog->setSource(QUrl("qrc:/qml/SignOnUiPage.qml"));
     } else {
         DEBUG() << "Setting request on handler";
         q->handler()->setRequest(this);
@@ -187,6 +180,7 @@
                 m_dialog->accept();
             }
         } else {
+            DEBUG();
             onFinished();
         }
     }
@@ -208,7 +202,7 @@
 
 void BrowserRequestPrivate::onLoadFinished(bool ok)
 {
-    Q_Q(const BrowserRequest);
+    Q_Q(BrowserRequest);
 
     DEBUG() << "Load finished" << ok;
 
@@ -219,9 +213,7 @@
 
     if (m_dialog && !m_dialog->isVisible()) {
         if (m_responseUrl.isEmpty()) {
-            Dialog::ShowMode mode =
-                (q->windowId() == 0) ? Dialog::TopLevel : Dialog::Transient;
-            m_dialog->show(q->windowId(), mode);
+            q->setWindow(m_dialog);
         } else {
             onFinished();
         }
@@ -277,6 +269,7 @@
 {
     Q_Q(BrowserRequest);
 
+    DEBUG();
     if (q->hasHandler()) {
         q->handler()->setRequest(0);
     } else if (m_dialog) {
@@ -284,23 +277,18 @@
     }
 }
 
-BrowserRequest::BrowserRequest(const QDBusConnection &connection,
-                               const QDBusMessage &message,
+BrowserRequest::BrowserRequest(int id,
+                               const QString &clientProfile,
                                const QVariantMap &parameters,
                                QObject *parent):
-    Request(connection, message, parameters, parent),
+    Request(id, clientProfile, parameters, parent),
     d_ptr(new BrowserRequestPrivate(this))
 {
 }
 
 BrowserRequest::~BrowserRequest()
 {
-}
-
-void BrowserRequest::removeIdentityData(quint32 id)
-{
-    QDir rootDir(BrowserRequestPrivate::rootDirForIdentity(id));
-    rootDir.removeRecursively();
+    delete d_ptr;
 }
 
 void BrowserRequest::start()
 
=== modified file 'online-accounts-ui/browser-request.h'
--- src/browser-request.h	2014-04-29 14:34:44 +0000
+++ online-accounts-ui/browser-request.h	2014-08-18 13:33:35 +0000
@@ -34,14 +34,12 @@
     Q_OBJECT
 
 public:
-    explicit BrowserRequest(const QDBusConnection &connection,
-                            const QDBusMessage &message,
+    explicit BrowserRequest(int id,
+                            const QString &clientProfile,
                             const QVariantMap &parameters,
                             QObject *parent = 0);
     ~BrowserRequest();
 
-    static void removeIdentityData(quint32 id);
-
     // reimplemented virtual methods
     void start();
 
 
=== modified file 'online-accounts-ui/globals.h'
--- src/globals.h	2014-04-29 12:11:55 +0000
+++ online-accounts-ui/globals.h	2014-08-18 13:33:35 +0000
@@ -29,6 +29,7 @@
 #define OAU_KEY_PROVIDER            QStringLiteral("provider")
 #define OAU_KEY_SERVICE_TYPE        QStringLiteral("serviceType")
 #define OAU_KEY_WINDOW_ID           QStringLiteral("windowId")
+#define OAU_KEY_PID                 QStringLiteral("pid")
 
 // D-Bus error names
 #define OAU_ERROR_PREFIX "com.ubuntu.OnlineAccountsUi."
 
=== added file 'online-accounts-ui/ipc.cpp'
--- online-accounts-ui/ipc.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-ui/ipc.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ipc.h"
+
+#include <QByteArray>
+#include <QFile>
+#include <QIODevice>
+#include <QSocketNotifier>
+
+using namespace OnlineAccountsUi;
+
+static const QByteArray welcomeMessage = "OAUinitIPC";
+
+namespace OnlineAccountsUi {
+
+class IpcPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(Ipc)
+
+public:
+    inline IpcPrivate(Ipc *ipc);
+    ~IpcPrivate() {};
+
+    void setChannels(QIODevice *readChannel, QIODevice *writeChannel);
+
+private Q_SLOTS:
+    void onReadyRead();
+
+private:
+    bool waitWelcomeMessage();
+
+private:
+    QIODevice *m_readChannel;
+    QIODevice *m_writeChannel;
+    int m_expectedLength;
+    bool m_gotWelcomeMessage;
+    QByteArray m_readBuffer;
+    mutable Ipc *q_ptr;
+};
+
+}; // namespace
+
+IpcPrivate::IpcPrivate(Ipc *ipc):
+    QObject(ipc),
+    m_readChannel(0),
+    m_writeChannel(0),
+    m_expectedLength(0),
+    m_gotWelcomeMessage(false),
+    q_ptr(ipc)
+{
+}
+
+void IpcPrivate::setChannels(QIODevice *readChannel, QIODevice *writeChannel)
+{
+    m_readChannel = readChannel;
+    m_writeChannel = writeChannel;
+    QObject::connect(m_readChannel, SIGNAL(readyRead()),
+                     this, SLOT(onReadyRead()));
+    /* QFile need special handling */
+    QFile *file = qobject_cast<QFile*>(m_readChannel);
+    if (file != 0) {
+        QSocketNotifier *notifier = new QSocketNotifier(file->handle(),
+                                                        QSocketNotifier::Read,
+                                                        this);
+        QObject::connect(notifier, SIGNAL(activated(int)),
+                         this, SLOT(onReadyRead()));
+    } else {
+        /* If the read channel is not a QFile, it means it's not the standard
+         * input, therefore we won't have the need to wait for the welcome
+         * message. */
+        m_gotWelcomeMessage = true;
+    }
+    onReadyRead();
+
+    file = qobject_cast<QFile*>(m_writeChannel);
+    if (file != 0) {
+        m_writeChannel->write(welcomeMessage);
+    }
+}
+
+void IpcPrivate::onReadyRead()
+{
+    Q_Q(Ipc);
+
+    while (true) {
+        if (m_expectedLength == 0) {
+            /* We are beginning a new read */
+
+            /* skip all noise */
+            if (!waitWelcomeMessage()) break;
+
+            int length;
+            int bytesRead = m_readChannel->read((char *)&length,
+                                                sizeof(length));
+            if (bytesRead < int(sizeof(length))) break;
+            m_expectedLength = length;
+            m_readBuffer.clear();
+        }
+
+        int neededBytes = m_expectedLength - m_readBuffer.length();
+        QByteArray buffer = m_readChannel->read(neededBytes);
+        m_readBuffer += buffer;
+        if (buffer.length() < neededBytes) break;
+        if (m_readBuffer.length() == m_expectedLength) {
+            Q_EMIT q->dataReady(m_readBuffer);
+            m_expectedLength = 0;
+        }
+    }
+}
+
+bool IpcPrivate::waitWelcomeMessage()
+{
+    if (m_gotWelcomeMessage) return true;
+
+    /* All Qt applications on the Nexus 4 write some dust to stdout when
+     * starting. So, skip all input until a well-defined welcome message is
+     * found */
+
+    QByteArray buffer;
+    int startCheckIndex = 0;
+    do {
+        buffer = m_readChannel->peek(40);
+        int found = buffer.indexOf(welcomeMessage, startCheckIndex);
+        int skip = (found >= 0) ? found : buffer.length() - welcomeMessage.length();
+        if (found >= 0) {
+            buffer = m_readChannel->read(skip + welcomeMessage.length());
+            m_gotWelcomeMessage = true;
+            return true;
+        }
+        if (skip > 0) {
+            buffer = m_readChannel->read(skip);
+        } else {
+            buffer.clear();
+        }
+    } while (!buffer.isEmpty());
+
+    return false;
+}
+
+Ipc::Ipc(QObject *parent):
+    QObject(parent),
+    d_ptr(new IpcPrivate(this))
+{
+}
+
+Ipc::~Ipc()
+{
+}
+
+void Ipc::setChannels(QIODevice *readChannel, QIODevice *writeChannel)
+{
+    Q_D(Ipc);
+    d->setChannels(readChannel, writeChannel);
+}
+
+void Ipc::write(const QByteArray &data)
+{
+    Q_D(Ipc);
+    int length = data.count();
+    d->m_writeChannel->write((char *)&length, sizeof(length));
+    d->m_writeChannel->write(data);
+    d->m_writeChannel->waitForBytesWritten(-1);
+}
+
+#include "ipc.moc"
 
=== added file 'online-accounts-ui/ipc.h'
--- online-accounts-ui/ipc.h	1970-01-01 00:00:00 +0000
+++ online-accounts-ui/ipc.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OAU_IPC_H
+#define OAU_IPC_H
+
+#include <QObject>
+
+class QByteArray;
+class QIODevice;
+
+#define OAU_OPERATION_CODE "code"
+#define OAU_OPERATION_CODE_PROCESS "process"
+#define OAU_OPERATION_CODE_REGISTER_HANDLER "newHandler"
+#define OAU_OPERATION_CODE_REQUEST_FINISHED "finished"
+#define OAU_OPERATION_CODE_REQUEST_FAILED "failed"
+#define OAU_OPERATION_ID "id"
+#define OAU_OPERATION_DATA "data"
+#define OAU_OPERATION_INTERFACE "interface"
+#define OAU_OPERATION_CLIENT_PROFILE "profile"
+#define OAU_OPERATION_ERROR_NAME "errname"
+#define OAU_OPERATION_ERROR_MESSAGE "errmsg"
+#define OAU_OPERATION_HANDLER_ID "handlerId"
+#define OAU_REQUEST_MATCH_KEY "X-RequestHandler"
+
+namespace OnlineAccountsUi {
+
+class IpcPrivate;
+class Ipc: public QObject
+{
+    Q_OBJECT
+
+public:
+    Ipc(QObject *parent = 0);
+    ~Ipc();
+
+    void setChannels(QIODevice *readChannel, QIODevice *writeChannel);
+    void write(const QByteArray &data);
+
+Q_SIGNALS:
+    void dataReady(QByteArray &data);
+
+private:
+    IpcPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(Ipc)
+};
+
+}; // namespace
+
+#endif // OAU_IPC_H
 
=== modified file 'online-accounts-ui/main.cpp'
--- src/main.cpp	2014-04-29 12:11:55 +0000
+++ online-accounts-ui/main.cpp	2014-08-18 13:33:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical Ltd.
+ * Copyright (C) 2013-2014 Canonical Ltd.
  *
  * Contact: Alberto Mardegan <[e-mail]>
  *
@@ -21,14 +21,9 @@
 #include "debug.h"
 #include "globals.h"
 #include "i18n.h"
-#include "inactivity-timer.h"
-#include "indicator-service.h"
-#include "request-manager.h"
-#include "service.h"
-#include "signonui-service.h"
+#include "ui-server.h"
 
 #include <QGuiApplication>
-#include <QDBusConnection>
 #include <QLibrary>
 #include <QProcessEnvironment>
 
@@ -37,7 +32,6 @@
 int main(int argc, char **argv)
 {
     QGuiApplication app(argc, argv);
-    app.setQuitOnLastWindowClosed(false);
 
     /* The testability driver is only loaded by QApplication but not by
      * QGuiApplication.  However, QApplication depends on QWidget which would
@@ -70,66 +64,22 @@
             setLoggingLevel(value);
     }
 
-    /* default daemonTimeout to 5 seconds */
-    int daemonTimeout = 5;
-
-    /* override daemonTimeout if OAU_DAEMON_TIMEOUT is set */
-    if (environment.contains(QLatin1String("OAU_DAEMON_TIMEOUT"))) {
-        bool isOk;
-        int value = environment.value(
-            QLatin1String("OAU_DAEMON_TIMEOUT")).toInt(&isOk);
-        if (isOk)
-            daemonTimeout = value;
-    }
-
     initTr(I18N_DOMAIN, NULL);
 
-    RequestManager *requestManager = new RequestManager();
-
-    Service *service = new Service();
-    QDBusConnection connection = QDBusConnection::sessionBus();
-    connection.registerService(OAU_SERVICE_NAME);
-    connection.registerObject(OAU_OBJECT_PATH, service);
-
-    SignOnUi::Service *signonuiService = new SignOnUi::Service();
-    connection.registerService(SIGNONUI_SERVICE_NAME);
-    connection.registerObject(SIGNONUI_OBJECT_PATH, signonuiService,
-                              QDBusConnection::ExportAllContents);
-
-    SignOnUi::IndicatorService *indicatorService =
-        new SignOnUi::IndicatorService();
-    connection.registerService(WEBCREDENTIALS_BUS_NAME);
-    connection.registerObject(WEBCREDENTIALS_OBJECT_PATH,
-                              indicatorService->serviceObject());
-
-
-    InactivityTimer *inactivityTimer = 0;
-    if (daemonTimeout > 0) {
-        inactivityTimer = new InactivityTimer(daemonTimeout * 1000);
-        inactivityTimer->watchObject(requestManager);
-        inactivityTimer->watchObject(indicatorService);
-        QObject::connect(inactivityTimer, SIGNAL(timeout()),
-                         &app, SLOT(quit()));
-    }
-
-    int ret = app.exec();
-
-    connection.unregisterService(WEBCREDENTIALS_BUS_NAME);
-    connection.unregisterObject(WEBCREDENTIALS_OBJECT_PATH);
-    delete indicatorService;
-
-    connection.unregisterService(SIGNONUI_SERVICE_NAME);
-    connection.unregisterObject(SIGNONUI_OBJECT_PATH);
-    delete signonuiService;
-
-    connection.unregisterService(OAU_SERVICE_NAME);
-    connection.unregisterObject(OAU_OBJECT_PATH);
-    delete service;
-
-    delete requestManager;
-
-    delete inactivityTimer;
-
-    return ret;
+    QStringList arguments = app.arguments();
+    int i = arguments.indexOf("--socket");
+    if (i < 0 || i + 1 >= arguments.count()) {
+        qWarning() << "Missing --socket argument";
+        return EXIT_FAILURE;
+    }
+
+    UiServer server(arguments[i + 1]);
+    QObject::connect(&server, SIGNAL(finished()),
+                     &app, SLOT(quit()));
+    if (Q_UNLIKELY(!server.init())) {
+        qWarning() << "Could not connect to socket";
+        return EXIT_FAILURE;
+    }
+
+    return app.exec();
 }
-
 
=== modified file 'online-accounts-ui/module/OAuth.qml'
--- src/module/OAuth.qml	2014-04-29 12:11:55 +0000
+++ online-accounts-ui/module/OAuth.qml	2014-08-18 13:33:35 +0000
@@ -55,7 +55,6 @@
             if (request) {
                 console.log("RequestHandler captured request!")
                 loader.setSource("WebView.qml", {
-                    "rootDir": request.rootDir,
                     "signonRequest": request
                 })
             } else {
 
=== modified file 'online-accounts-ui/module/WebView.qml'
--- src/module/WebView.qml	2014-04-29 12:11:55 +0000
+++ online-accounts-ui/module/WebView.qml	2014-08-18 13:33:35 +0000
@@ -5,7 +5,6 @@
 
 UbuntuWebView {
     property QtObject signonRequest
-    property url rootDir
 
     Component.onCompleted: url = signonRequest.startUrl
 
@@ -22,6 +21,6 @@
     onUrlChanged: signonRequest.currentUrl = url
 
     context: UbuntuWebContext {
-        dataPath: rootDir
+        dataPath: signonRequest.rootDir
     }
 }
 
=== modified file 'online-accounts-ui/module/qmldir.in'
--- src/module/qmldir.in	2013-06-05 11:33:39 +0000
+++ online-accounts-ui/module/qmldir.in	2014-08-18 13:33:35 +0000
@@ -1,7 +1,9 @@
 module $${API_URI}
+KeyboardRectangle 1.0 KeyboardRectangle.qml
 OAuthMain 1.0 OAuthMain.qml
 OAuth 1.0 OAuth.qml
 Options 1.0 Options.qml
 RemovalConfirmation 1.0 RemovalConfirmation.qml
 ServiceItem 1.0 ServiceItem.qml
 ServiceSwitches 1.0 ServiceSwitches.qml
+WebView 1.0 WebView.qml
 
=== modified file 'online-accounts-ui/notification.cpp'
--- src/notification.cpp	2014-06-05 13:28:30 +0000
+++ online-accounts-ui/notification.cpp	2014-08-18 13:33:35 +0000
@@ -108,6 +108,14 @@
                                    this, NULL);
 }
 
+void Notification::setSnapDecision(bool snapDecision)
+{
+    Q_D(Notification);
+    notify_notification_set_hint(d->m_notification,
+                                 "x-canonical-snap-decisions",
+                                 g_variant_new_boolean(snapDecision));
+}
+
 void Notification::show()
 {
     Q_D(Notification);
 
=== modified file 'online-accounts-ui/notification.h'
--- src/notification.h	2014-06-05 13:28:30 +0000
+++ online-accounts-ui/notification.h	2014-08-18 13:33:35 +0000
@@ -37,6 +37,7 @@
     ~Notification();
 
     void addAction(const QString &action, const QString &label);
+    void setSnapDecision(bool snapDecision);
 
 public Q_SLOTS:
     void show();
 
=== renamed file 'src/online-accounts-ui.pro' => 'online-accounts-ui/online-accounts-ui-helper.pro'
--- src/online-accounts-ui.pro	2014-06-05 13:28:30 +0000
+++ online-accounts-ui/online-accounts-ui-helper.pro	2014-08-18 13:33:35 +0000
@@ -21,16 +21,10 @@
     libsignon-qt5 \
     signon-plugins-common
 
-I18N_DOMAIN="ubuntu-system-settings-online-accounts"
-SIGNONUI_I18N_DOMAIN="signon-ui"
-
 DEFINES += \
     I18N_DOMAIN=\\\"$${I18N_DOMAIN}\\\" \
     SIGNONUI_I18N_DOMAIN=\\\"$${SIGNONUI_I18N_DOMAIN}\\\"
 
-DBUS_ADAPTORS += \
-    com.ubuntu.OnlineAccountsUi.xml
-
 DEFINES += \
     DEBUG_ENABLED \
     OAU_PLUGIN_DIR=\\\"$${ONLINE_ACCOUNTS_PLUGIN_DIR}/\\\" \
@@ -44,19 +38,15 @@
     debug.cpp \
     dialog.cpp \
     i18n.cpp \
-    inactivity-timer.cpp \
-    indicator-service.cpp \
+    ipc.cpp \
     main.cpp \
     notification.cpp \
     panel-request.cpp \
     provider-request.cpp \
-    reauthenticator.cpp \
     request.cpp \
     request-handler.cpp \
-    request-manager.cpp \
-    service.cpp \
     signonui-request.cpp \
-    signonui-service.cpp
+    ui-server.cpp
 
 HEADERS += \
     access-model.h \
@@ -66,33 +56,20 @@
     debug.h \
     dialog.h \
     i18n.h \
-    inactivity-timer.h \
-    indicator-service.h \
+    ipc.h \
     notification.h \
     panel-request.h \
     provider-request.h \
-    reauthenticator.h \
     request.h \
     request-handler.h \
-    request-manager.h \
-    service.h \
     signonui-request.h \
-    signonui-service.h
+    ui-server.h
 
 QML_SOURCES = \
     qml/AccountCreationPage.qml \
-    qml/AccountEditPage.qml \
-    qml/AccountItem.qml \
-    qml/AccountsPage.qml \
-    qml/AddAccountLabel.qml \
     qml/AuthorizationPage.qml \
-    qml/MainPage.qml \
-    qml/NewAccountPage.qml \
-    qml/NoAccountsPage.qml \
-    qml/NormalStartupPage.qml \
-    qml/ProviderPluginList.qml \
     qml/ProviderRequest.qml \
-    qml/ProvidersList.qml
+    qml/SignOnUiPage.qml
 
 RESOURCES += \
     ui.qrc
@@ -102,17 +79,8 @@
     $${RESOURCES}
 
 QMAKE_SUBSTITUTES += \
-    com.ubuntu.OnlineAccountsUi.service.in \
     online-accounts-ui.desktop.in
 
-DBUS_ADAPTORS += \
-    com.canonical.indicators.webcredentials.xml
-
-service.path = $${INSTALL_PREFIX}/share/dbus-1/services
-service.files = \
-    com.ubuntu.OnlineAccountsUi.service
-INSTALLS += service
-
 desktop.path = $${INSTALL_PREFIX}/share/applications
 desktop.files += online-accounts-ui.desktop
 INSTALLS += desktop
 
=== renamed file 'src/src.pro' => 'online-accounts-ui/online-accounts-ui.pro'
--- src/src.pro	2014-04-29 12:11:55 +0000
+++ online-accounts-ui/online-accounts-ui.pro	2014-08-18 13:33:35 +0000
@@ -1,4 +1,4 @@
 TEMPLATE = subdirs
 SUBDIRS = \
     module \
-    online-accounts-ui.pro
+    online-accounts-ui-helper.pro
 
=== modified file 'online-accounts-ui/panel-request.cpp'
--- src/panel-request.cpp	2014-05-30 08:09:02 +0000
+++ online-accounts-ui/panel-request.cpp	2014-08-18 13:33:35 +0000
@@ -65,7 +65,9 @@
 PanelRequestPrivate::~PanelRequestPrivate()
 {
     DEBUG() << "view:" << m_view;
+    /* TODO Uncomment this once QTBUG-40766 is resolved:
     delete m_view;
+    */
 }
 
 void PanelRequestPrivate::start()
@@ -103,18 +105,15 @@
 
     if (!visible) {
         q->setResult(QVariantMap());
-        /* FIXME HACK: remove when window reparenting is implemented */
-        if (QGuiApplication::platformName().startsWith("ubuntu")) {
-            QDesktopServices::openUrl(QUrl("application:///ubuntu-system-settings.desktop"));
-        }
     }
 }
 
-PanelRequest::PanelRequest(const QDBusConnection &connection,
-                           const QDBusMessage &message,
+PanelRequest::PanelRequest(const QString &interface,
+                           int id,
+                           const QString &clientProfile,
                            const QVariantMap &parameters,
                            QObject *parent):
-    Request(connection, message, parameters, parent),
+    Request(interface, id, clientProfile, parameters, parent),
     d_ptr(new PanelRequestPrivate(this))
 {
 }
 
=== modified file 'online-accounts-ui/panel-request.h'
--- src/panel-request.h	2014-05-30 08:09:02 +0000
+++ online-accounts-ui/panel-request.h	2014-08-18 13:33:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical Ltd.
+ * Copyright (C) 2013-2014 Canonical Ltd.
  *
  * Contact: Alberto Mardegan <[e-mail]>
  *
@@ -31,8 +31,9 @@
     Q_OBJECT
 
 public:
-    explicit PanelRequest(const QDBusConnection &connection,
-                          const QDBusMessage &message,
+    explicit PanelRequest(const QString &interface,
+                          int id,
+                          const QString &clientProfile,
                           const QVariantMap &parameters,
                           QObject *parent = 0);
     ~PanelRequest();
 
=== modified file 'online-accounts-ui/provider-request.cpp'
--- src/provider-request.cpp	2014-05-30 09:28:43 +0000
+++ online-accounts-ui/provider-request.cpp	2014-08-18 13:33:35 +0000
@@ -164,11 +164,12 @@
     m_view->close();
 }
 
-ProviderRequest::ProviderRequest(const QDBusConnection &connection,
-                                 const QDBusMessage &message,
+ProviderRequest::ProviderRequest(const QString &interface,
+                                 int id,
+                                 const QString &clientProfile,
                                  const QVariantMap &parameters,
                                  QObject *parent):
-    Request(connection, message, parameters, parent),
+    Request(interface, id, clientProfile, parameters, parent),
     d_ptr(new ProviderRequestPrivate(this))
 {
 }
 
=== modified file 'online-accounts-ui/provider-request.h'
--- src/provider-request.h	2014-02-03 10:27:39 +0000
+++ online-accounts-ui/provider-request.h	2014-08-18 13:33:35 +0000
@@ -31,8 +31,9 @@
     Q_OBJECT
 
 public:
-    explicit ProviderRequest(const QDBusConnection &connection,
-                             const QDBusMessage &message,
+    explicit ProviderRequest(const QString &interface,
+                             int id,
+                             const QString &clientProfile,
                              const QVariantMap &parameters,
                              QObject *parent = 0);
     ~ProviderRequest();
 
=== modified file 'online-accounts-ui/qml/ProviderRequest.qml'
--- src/qml/ProviderRequest.qml	2014-05-29 21:14:11 +0000
+++ online-accounts-ui/qml/ProviderRequest.qml	2014-08-18 13:33:35 +0000
@@ -54,7 +54,7 @@
                 id: loader
                 anchors.fill: parent
                 active: false
-                sourceComponent: accessModel.count <= 1 ? accountCreationPage : authorizationPage
+                sourceComponent: (accessModel.count <= 1 || applicationInfo.id === "system-settings") ? accountCreationPage : authorizationPage
                 onLoaded: {
                     // use this trick to break the sourceComponent binding
                     var tmp = sourceComponent
@@ -165,10 +165,17 @@
     }
 
     function grantAccessIfReady() {
-        if (root.__createdAccountId != 0 &&
-            accountsModel.indexOfAccount(root.__createdAccountId) >= 0) {
-            root.grantAccess(root.__createdAccountId)
-            root.__createdAccountId = 0
+        if (root.__createdAccountId != 0) {
+            // If the request comes from system settings, stop here
+            if (applicationInfo.id === "system-settings") {
+                root.allowed(root.__createdAccountId)
+                return
+            }
+
+            if (accountsModel.indexOfAccount(root.__createdAccountId) >= 0) {
+                root.grantAccess(root.__createdAccountId)
+                root.__createdAccountId = 0
+            }
         }
     }
 
 
=== added file 'online-accounts-ui/qml/SignOnUiPage.qml'
--- online-accounts-ui/qml/SignOnUiPage.qml	1970-01-01 00:00:00 +0000
+++ online-accounts-ui/qml/SignOnUiPage.qml	2014-08-18 13:33:35 +0000
@@ -0,0 +1,40 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.OnlineAccounts.Plugin 1.0
+
+MainView {
+    id: root
+
+    property var signonRequest: request
+
+    width: units.gu(60)
+    height: units.gu(90)
+
+    Page {
+        WebView {
+            id: loader
+            signonRequest: root.signonRequest
+
+            anchors {
+                fill: parent
+                bottomMargin: Math.max(osk.height, cancelButton.height)
+            }
+        }
+
+        ListItem.SingleControl {
+            id: cancelButton
+            anchors.bottom: parent.bottom
+            showDivider: false
+            control: Button {
+                text: i18n.dtr("ubuntu-system-settings-online-accounts", "Cancel")
+                width: parent.width - units.gu(4)
+                onClicked: signonRequest.cancel()
+            }
+        }
+
+        KeyboardRectangle {
+            id: osk
+        }
+    }
+}
 
=== modified file 'online-accounts-ui/request-handler.cpp'
--- src/request-handler.cpp	2014-04-29 14:34:44 +0000
+++ online-accounts-ui/request-handler.cpp	2014-08-18 13:33:35 +0000
@@ -21,6 +21,7 @@
 #include "request-handler.h"
 
 #include "debug.h"
+#include "ui-server.h"
 
 #include <SignOn/uisessiondata_priv.h>
 #include <QDBusArgument>
@@ -66,6 +67,11 @@
     d_ptr(new RequestHandlerPrivate(this))
 {
     allRequestHandlers.append(this);
+
+    OnlineAccountsUi::UiServer *server =
+        OnlineAccountsUi::UiServer::instance();
+    Q_ASSERT(server);
+    server->registerHandler(this);
 }
 
 RequestHandler::~RequestHandler()
 
=== modified file 'online-accounts-ui/request.cpp'
--- src/request.cpp	2014-05-30 08:09:02 +0000
+++ online-accounts-ui/request.cpp	2014-08-18 13:33:35 +0000
@@ -51,8 +51,9 @@
     Q_DECLARE_PUBLIC(Request)
 
 public:
-    RequestPrivate(const QDBusConnection &connection,
-                   const QDBusMessage &message,
+    RequestPrivate(const QString &interface,
+                   int id,
+                   const QString &clientProfile,
                    const QVariantMap &parameters,
                    Request *request);
     ~RequestPrivate();
@@ -63,33 +64,36 @@
 
 private:
     void setWindow(QWindow *window);
-    QString findClientApparmorProfile();
 
 private:
     mutable Request *q_ptr;
-    QDBusConnection m_connection;
-    QDBusMessage m_message;
+    QString m_interface;
+    int m_id;
     QVariantMap m_parameters;
     QString m_clientApparmorProfile;
     bool m_inProgress;
     QPointer<QWindow> m_window;
+    QString m_errorName;
+    QString m_errorMessage;
+    QVariantMap m_result;
 };
 
 } // namespace
 
-RequestPrivate::RequestPrivate(const QDBusConnection &connection,
-                               const QDBusMessage &message,
+RequestPrivate::RequestPrivate(const QString &interface,
+                               int id,
+                               const QString &clientProfile,
                                const QVariantMap &parameters,
                                Request *request):
     QObject(request),
     q_ptr(request),
-    m_connection(connection),
-    m_message(message),
+    m_interface(interface),
+    m_id(id),
     m_parameters(parameters),
+    m_clientApparmorProfile(clientProfile),
     m_inProgress(false),
     m_window(0)
 {
-    m_clientApparmorProfile = findClientApparmorProfile();
 }
 
 RequestPrivate::~RequestPrivate()
@@ -113,41 +117,14 @@
     window->show();
 }
 
-QString RequestPrivate::findClientApparmorProfile()
-{
-    QString uniqueConnectionId = m_message.service();
-    /* This is mainly for unit tests: real messages on the session bus always
-     * have a service name. */
-    if (uniqueConnectionId.isEmpty()) return QString();
-
-    QString appId;
-
-    QDBusMessage msg =
-        QDBusMessage::createMethodCall("org.freedesktop.DBus",
-                                       "/org/freedesktop/DBus",
-                                       "org.freedesktop.DBus",
-                                       "GetConnectionAppArmorSecurityContext");
-    QVariantList args;
-    args << uniqueConnectionId;
-    msg.setArguments(args);
-    QDBusMessage reply = QDBusConnection::sessionBus().call(msg, QDBus::Block);
-    if (reply.type() == QDBusMessage::ReplyMessage) {
-        appId = reply.arguments().value(0, QString()).toString();
-        DEBUG() << "App ID:" << appId;
-    } else {
-        qWarning() << "Error getting app ID:" << reply.errorName() <<
-            reply.errorMessage();
-    }
-    return appId;
-}
-
 /* Some unit tests might need to provide a different implementation for the
  * Request::newRequest() factory method; for this reason, we allow the method
  * to be excluded from compilation.
  */
 #ifndef NO_REQUEST_FACTORY
-Request *Request::newRequest(const QDBusConnection &connection,
-                             const QDBusMessage &message,
+Request *Request::newRequest(const QString &interface,
+                             int id,
+                             const QString &clientProfile,
                              const QVariantMap &parameters,
                              QObject *parent)
 {
@@ -155,26 +132,29 @@
      * different subclasses for handling them, and in this method we examine
      * the @parameters argument to figure out which subclass is the most apt to
      * handle the request. */
-    if (message.interface() == OAU_INTERFACE) {
+    if (interface == OAU_INTERFACE) {
         if (parameters.contains(OAU_KEY_PROVIDER)) {
-            return new ProviderRequest(connection, message, parameters, parent);
+            return new ProviderRequest(interface, id, clientProfile,
+                                       parameters, parent);
         } else {
-            return new PanelRequest(connection, message, parameters, parent);
+            return new PanelRequest(interface, id, clientProfile,
+                                    parameters, parent);
         }
     } else {
-        Q_ASSERT(message.interface() == SIGNONUI_INTERFACE);
-        return SignOnUi::Request::newRequest(connection, message,
+        Q_ASSERT(interface == SIGNONUI_INTERFACE);
+        return SignOnUi::Request::newRequest(id, clientProfile,
                                              parameters, parent);
     }
 }
 #endif
 
-Request::Request(const QDBusConnection &connection,
-                 const QDBusMessage &message,
+Request::Request(const QString &interface,
+                 int id,
+                 const QString &clientProfile,
                  const QVariantMap &parameters,
                  QObject *parent):
     QObject(parent),
-    d_ptr(new RequestPrivate(connection, message, parameters, this))
+    d_ptr(new RequestPrivate(interface, id, clientProfile, parameters, this))
 {
     allRequests.append(this);
 }
@@ -195,6 +175,18 @@
     return 0;
 }
 
+QString Request::interface() const
+{
+    Q_D(const Request);
+    return d->m_interface;
+}
+
+int Request::id() const
+{
+    Q_D(const Request);
+    return d->m_id;
+}
+
 void Request::setWindow(QWindow *window)
 {
     Q_D(Request);
@@ -231,6 +223,24 @@
     return d->m_window;
 }
 
+QVariantMap Request::result() const
+{
+    Q_D(const Request);
+    return d->m_result;
+}
+
+QString Request::errorName() const
+{
+    Q_D(const Request);
+    return d->m_errorName;
+}
+
+QString Request::errorMessage() const
+{
+    Q_D(const Request);
+    return d->m_errorMessage;
+}
+
 void Request::start()
 {
     Q_D(Request);
@@ -249,8 +259,11 @@
 void Request::fail(const QString &name, const QString &message)
 {
     Q_D(Request);
-    QDBusMessage reply = d->m_message.createErrorReply(name, message);
-    d->m_connection.send(reply);
+
+    DEBUG() << name << message;
+
+    d->m_errorName = name;
+    d->m_errorMessage = message;
 
     Q_EMIT completed();
 }
@@ -268,8 +281,8 @@
 {
     Q_D(Request);
     if (d->m_inProgress) {
-        QDBusMessage reply = d->m_message.createReply(result);
-        d->m_connection.send(reply);
+        DEBUG() << result;
+        d->m_result = result;
 
         Q_EMIT completed();
         d->m_inProgress = false;
 
=== modified file 'online-accounts-ui/request.h'
--- src/request.h	2014-05-30 08:09:02 +0000
+++ online-accounts-ui/request.h	2014-08-18 13:33:35 +0000
@@ -21,8 +21,6 @@
 #ifndef OAU_REQUEST_H
 #define OAU_REQUEST_H
 
-#include <QDBusConnection>
-#include <QDBusMessage>
 #include <QObject>
 #include <QVariantMap>
 #include <QWindow>
@@ -35,20 +33,27 @@
     Q_OBJECT
 
 public:
-    static Request *newRequest(const QDBusConnection &connection,
-                               const QDBusMessage &message,
+    static Request *newRequest(const QString &interface,
+                               int id,
+                               const QString &clientProfile,
                                const QVariantMap &parameters,
                                QObject *parent = 0);
     ~Request();
 
     static Request *find(const QVariantMap &match);
 
+    QString interface() const;
+    int id() const;
     WId windowId() const;
     bool isInProgress() const;
     const QVariantMap &parameters() const;
     QString clientApparmorProfile() const;
     QWindow *window() const;
 
+    QVariantMap result() const;
+    QString errorName() const;
+    QString errorMessage() const;
+
 public Q_SLOTS:
     virtual void start();
     void cancel();
@@ -57,8 +62,9 @@
     void completed();
 
 protected:
-    explicit Request(const QDBusConnection &connection,
-                     const QDBusMessage &message,
+    explicit Request(const QString &interface,
+                     int id,
+                     const QString &clientProfile,
                      const QVariantMap &parameters,
                      QObject *parent = 0);
     virtual void setWindow(QWindow *window);
 
=== modified file 'online-accounts-ui/signonui-request.cpp'
--- src/signonui-request.cpp	2014-06-05 13:28:30 +0000
+++ online-accounts-ui/signonui-request.cpp	2014-08-18 13:33:35 +0000
@@ -1,7 +1,7 @@
 /*
  * This file is part of online-accounts-ui
  *
- * Copyright (C) 2011 Canonical Ltd.
+ * Copyright (C) 2011-2014 Canonical Ltd.
  *
  * Contact: Alberto Mardegan <[e-mail]>
  *
@@ -20,14 +20,19 @@
 
 #include "signonui-request.h"
 
+#include "account-manager.h"
+#include "application-manager.h"
 #include "browser-request.h"
 #include "debug.h"
 #include "globals.h"
-#include "indicator-service.h"
+#include "notification.h"
+#include "request-handler.h"
 
 #include <Accounts/Account>
-#include <Accounts/Manager>
+#include <Accounts/Application>
+#include <Accounts/Provider>
 #include <QDBusArgument>
+#include <QPointer>
 #include <SignOn/uisessiondata.h>
 #include <SignOn/uisessiondata_priv.h>
 
@@ -45,16 +50,19 @@
     ~RequestPrivate();
 
 private:
-    bool setWindow(QWindow *window);
+    void setWindow(QWindow *window);
     Accounts::Account *findAccount();
-    bool dispatchToIndicator();
+
+private Q_SLOTS:
+    void onActionInvoked(const QString &action);
+    void onNotificationClosed();
 
 private:
     mutable Request *q_ptr;
     QVariantMap m_clientData;
-    bool m_inProgress;
-    RequestHandler *m_handler;
-    Accounts::Manager *m_accountManager;
+    QPointer<RequestHandler> m_handler;
+    OnlineAccountsUi::Notification *m_notification;
+    QWindow *m_window;
 };
 
 } // namespace
@@ -62,9 +70,9 @@
 RequestPrivate::RequestPrivate(Request *request):
     QObject(request),
     q_ptr(request),
-    m_inProgress(false),
     m_handler(0),
-    m_accountManager(0)
+    m_notification(0),
+    m_window(0)
 {
     const QVariantMap &parameters = request->parameters();
     if (parameters.contains(SSOUI_KEY_CLIENT_DATA)) {
@@ -77,20 +85,51 @@
 
 RequestPrivate::~RequestPrivate()
 {
+    delete m_notification;
+    m_notification = 0;
 }
 
-bool RequestPrivate::setWindow(QWindow *window)
+void RequestPrivate::setWindow(QWindow *window)
 {
     Q_Q(Request);
-    Q_UNUSED(window);
 
-    /* If the window has no parent and the webcredentials indicator service is
-     * up, dispatch the request to it. */
-    if (q->windowId() == 0 && dispatchToIndicator()) {
-        return true;
+    /* Don't show the window yet: the user must be presented with a
+     * snap-decision, and we'll show the window only if he decides to
+     * authenticate. */
+    Accounts::Account *account = findAccount();
+    if (Q_UNLIKELY(!account)) {
+        QVariantMap result;
+        result[SSOUI_KEY_ERROR] = SignOn::QUERY_ERROR_FORBIDDEN;
+        q->setResult(result);
+        return;
     }
 
-    return false;
+    OnlineAccountsUi::ApplicationManager *appManager =
+        OnlineAccountsUi::ApplicationManager::instance();
+    Accounts::Application application =
+        appManager->applicationFromProfile(q->clientApparmorProfile());
+
+    OnlineAccountsUi::AccountManager *accountManager =
+        OnlineAccountsUi::AccountManager::instance();
+    Accounts::Provider provider =
+        accountManager->provider(account->providerName());
+
+    QString summary =
+        QString("Please authorize %1 to access your %2 account %3").
+        arg(application.isValid() ? application.displayName() : "Ubuntu").
+        arg(provider.displayName()).
+        arg(account->displayName());
+    m_notification =
+        new OnlineAccountsUi::Notification("Authentication request", summary);
+    m_notification->addAction("cancel", "Cancel");
+    m_notification->addAction("continue", "Authorize...");
+    m_notification->setSnapDecision(true);
+    QObject::connect(m_notification, SIGNAL(actionInvoked(const QString &)),
+                     this, SLOT(onActionInvoked(const QString &)));
+    QObject::connect(m_notification, SIGNAL(closed()),
+                     this, SLOT(onNotificationClosed()));
+    m_notification->show();
+    m_window = window;
 }
 
 Accounts::Account *RequestPrivate::findAccount()
@@ -104,11 +143,10 @@
     /* Find the account using this identity.
      * FIXME: there might be more than one!
      */
-    if (m_accountManager == 0) {
-        m_accountManager = new Accounts::Manager(this);
-    }
-    Q_FOREACH(Accounts::AccountId accountId, m_accountManager->accountList()) {
-        Accounts::Account *account = m_accountManager->account(accountId);
+    OnlineAccountsUi::AccountManager *manager =
+        OnlineAccountsUi::AccountManager::instance();
+    Q_FOREACH(Accounts::AccountId accountId, manager->accountList()) {
+        Accounts::Account *account = manager->account(accountId);
         if (account == 0) continue;
 
         QVariant value(QVariant::UInt);
@@ -122,52 +160,60 @@
     return 0;
 }
 
-bool RequestPrivate::dispatchToIndicator()
+void RequestPrivate::onActionInvoked(const QString &action)
 {
     Q_Q(Request);
 
-    Accounts::Account *account = findAccount();
-    if (account == 0) {
-        return false;
+    DEBUG() << action;
+
+    QObject::disconnect(m_notification, 0, this, 0);
+    m_notification->deleteLater();
+    m_notification = 0;
+
+    if (action == QStringLiteral("continue")) {
+        q->setWindow(m_window);
+    } else {
+        q->cancel();
     }
-
-    QVariantMap notification;
-    notification["DisplayName"] = account->displayName();
-    notification["ClientData"] = m_clientData;
-    notification["Identity"] = q->identity();
-    notification["Method"] = q->method();
-    notification["Mechanism"] = q->mechanism();
-
-    IndicatorService *indicator = IndicatorService::instance();
-    indicator->reportFailure(account->id(), notification);
-
-    /* the account has been reported as failing. We can now close this
-     * request, and tell the application that UI interaction is forbidden.
-     */
+}
+
+void RequestPrivate::onNotificationClosed()
+{
+    Q_Q(Request);
+
+    DEBUG();
+
+    /* setResult() should have been called by onActionInvoked(), but calling it
+     * twice won't harm because only the first invocation counts. */
     QVariantMap result;
     result[SSOUI_KEY_ERROR] = SignOn::QUERY_ERROR_FORBIDDEN;
     q->setResult(result);
-    return true;
+
+    m_notification->deleteLater();
+    m_notification = 0;
 }
 
-Request *Request::newRequest(const QDBusConnection &connection,
-                             const QDBusMessage &message,
+#ifndef NO_REQUEST_FACTORY
+Request *Request::newRequest(int id,
+                             const QString &clientProfile,
                              const QVariantMap &parameters,
                              QObject *parent)
 {
     if (parameters.contains(SSOUI_KEY_OPENURL)) {
-        return new SignOnUi::BrowserRequest(connection, message,
+        return new SignOnUi::BrowserRequest(id, clientProfile,
                                             parameters, parent);
     } else {
         return 0; // TODO new DialogRequest(connection, message, parameters, parent);
     }
 }
+#endif
 
-Request::Request(const QDBusConnection &connection,
-                 const QDBusMessage &message,
+Request::Request(int id,
+                 const QString &clientProfile,
                  const QVariantMap &parameters,
                  QObject *parent):
-    OnlineAccountsUi::Request(connection, message, parameters, parent),
+    OnlineAccountsUi::Request(SIGNONUI_INTERFACE, id, clientProfile,
+                              parameters, parent),
     d_ptr(new RequestPrivate(this))
 {
 }
@@ -176,21 +222,35 @@
 {
 }
 
-QString Request::id(const QVariantMap &parameters)
+QString Request::ssoId(const QVariantMap &parameters)
 {
     return parameters[SSOUI_KEY_REQUESTID].toString();
 }
 
-QString Request::id() const
+QString Request::ssoId() const
 {
-    return Request::id(parameters());
+    return Request::ssoId(parameters());
 }
 
 void Request::setWindow(QWindow *window)
 {
     Q_D(Request);
-    if (!d->setWindow(window))
+
+    /* While a notification is shown, ignore any further calls to
+     * setWindow(). */
+    if (d->m_notification) return;
+
+    /* The first time that this method is called, we handle it by presenting a
+     * snap decision to the user.
+     * Then, if this is called again with the same QWindow, it means that the
+     * snap decision was accepted, and we show the window.
+     */
+    if (window == d->m_window) {
         OnlineAccountsUi::Request::setWindow(window);
+        d->m_window = 0;
+    } else {
+        d->setWindow(window);
+    }
 }
 
 uint Request::identity() const
@@ -232,12 +292,10 @@
 
 void Request::setCanceled()
 {
-    if (isInProgress()) {
-        QVariantMap result;
-        result[SSOUI_KEY_ERROR] = SignOn::QUERY_ERROR_CANCELED;
+    QVariantMap result;
+    result[SSOUI_KEY_ERROR] = SignOn::QUERY_ERROR_CANCELED;
 
-        setResult(result);
-    }
+    setResult(result);
 }
 
 #include "signonui-request.moc"
 
=== modified file 'online-accounts-ui/signonui-request.h'
--- src/signonui-request.h	2014-04-29 14:34:44 +0000
+++ online-accounts-ui/signonui-request.h	2014-08-18 13:33:35 +0000
@@ -33,14 +33,14 @@
     Q_OBJECT
 
 public:
-    static Request *newRequest(const QDBusConnection &connection,
-                               const QDBusMessage &message,
+    static Request *newRequest(int id,
+                               const QString &clientProfile,
                                const QVariantMap &parameters,
                                QObject *parent = 0);
     ~Request();
 
-    static QString id(const QVariantMap &parameters);
-    QString id() const;
+    static QString ssoId(const QVariantMap &parameters);
+    QString ssoId() const;
 
     uint identity() const;
     QString method() const;
@@ -53,8 +53,8 @@
     bool hasHandler() const { return handler() != 0; }
 
 protected:
-    explicit Request(const QDBusConnection &connection,
-                     const QDBusMessage &message,
+    explicit Request(int id,
+                     const QString &clientProfile,
                      const QVariantMap &parameters,
                      QObject *parent = 0);
     virtual void setWindow(QWindow *window) Q_DECL_OVERRIDE;
 
=== added file 'online-accounts-ui/ui-server.cpp'
--- online-accounts-ui/ui-server.cpp	1970-01-01 00:00:00 +0000
+++ online-accounts-ui/ui-server.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "ipc.h"
+#include "request.h"
+#include "request-handler.h"
+#include "signonui-request.h"
+#include "ui-server.h"
+
+#include <QLocalSocket>
+#include <QtQml>
+#include <SignOn/uisessiondata_priv.h>
+
+using namespace OnlineAccountsUi;
+
+static UiServer *m_instance = 0;
+
+namespace OnlineAccountsUi {
+
+class UiServerPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(UiServer)
+
+public:
+    inline UiServerPrivate(const QString &address, UiServer *pluginServer);
+    inline ~UiServerPrivate();
+
+    bool setupSocket();
+    bool init();
+    void sendOperation(const QVariantMap &data);
+
+private Q_SLOTS:
+    void onDataReady(QByteArray &data);
+    void onRequestCompleted();
+
+private:
+    QLocalSocket m_socket;
+    OnlineAccountsUi::Ipc m_ipc;
+    mutable UiServer *q_ptr;
+};
+
+} // namespace
+
+UiServerPrivate::UiServerPrivate(const QString &address,
+                                 UiServer *pluginServer):
+    QObject(pluginServer),
+    q_ptr(pluginServer)
+{
+    QObject::connect(&m_ipc, SIGNAL(dataReady(QByteArray &)),
+                     this, SLOT(onDataReady(QByteArray &)));
+    QObject::connect(&m_socket, SIGNAL(disconnected()),
+                     q_ptr, SIGNAL(finished()));
+    m_socket.connectToServer(address);
+}
+
+UiServerPrivate::~UiServerPrivate()
+{
+    DEBUG();
+}
+
+void UiServerPrivate::sendOperation(const QVariantMap &data)
+{
+    QByteArray ba;
+    QDataStream stream(&ba, QIODevice::WriteOnly);
+    stream << data;
+    m_ipc.write(ba);
+}
+
+void UiServerPrivate::onDataReady(QByteArray &data)
+{
+    Q_Q(UiServer);
+
+    QVariantMap map;
+    QDataStream stream(&data, QIODevice::ReadOnly);
+    stream >> map;
+
+    DEBUG() << map;
+
+    QString code = map.value(OAU_OPERATION_CODE).toString();
+    if (code == OAU_OPERATION_CODE_PROCESS) {
+        QVariantMap parameters = map[OAU_OPERATION_DATA].toMap();
+        Request *request =
+            Request::newRequest(map[OAU_OPERATION_INTERFACE].toString(),
+                                map[OAU_OPERATION_ID].toInt(),
+                                map[OAU_OPERATION_CLIENT_PROFILE].toString(),
+                                parameters,
+                                this);
+        QObject::connect(request, SIGNAL(completed()),
+                         this, SLOT(onRequestCompleted()));
+
+        /* Check if a RequestHandler has been setup to handle this request. If
+         * so, bing the request object to the handler and start the request
+         * immediately. */
+        SignOnUi::Request *signonRequest =
+            qobject_cast<SignOnUi::Request*>(request);
+        if (signonRequest) {
+            SignOnUi::RequestHandler *handler =
+                SignOnUi::RequestHandler::findMatching(parameters);
+            if (handler) {
+                signonRequest->setHandler(handler);
+            }
+        }
+        request->start();
+    } else {
+        qWarning() << "Invalid operation code: " << code;
+    }
+}
+
+void UiServerPrivate::onRequestCompleted()
+{
+    Request *request = qobject_cast<Request*>(sender());
+    request->disconnect(this);
+    request->deleteLater();
+
+    if (request->errorName().isEmpty()) {
+        QVariantMap operation;
+        operation.insert(OAU_OPERATION_CODE,
+                         OAU_OPERATION_CODE_REQUEST_FINISHED);
+        operation.insert(OAU_OPERATION_ID, request->id());
+        operation.insert(OAU_OPERATION_DATA, request->result());
+        operation.insert(OAU_OPERATION_INTERFACE, request->interface());
+        sendOperation(operation);
+    } else {
+        QVariantMap operation;
+        operation.insert(OAU_OPERATION_CODE,
+                         OAU_OPERATION_CODE_REQUEST_FAILED);
+        operation.insert(OAU_OPERATION_ID, request->id());
+        operation.insert(OAU_OPERATION_INTERFACE, request->interface());
+        operation.insert(OAU_OPERATION_ERROR_NAME, request->errorName());
+        operation.insert(OAU_OPERATION_ERROR_MESSAGE, request->errorMessage());
+        sendOperation(operation);
+    }
+}
+
+bool UiServerPrivate::init()
+{
+    if (Q_UNLIKELY(!m_socket.waitForConnected())) return false;
+
+    m_ipc.setChannels(&m_socket, &m_socket);
+    return true;
+}
+
+UiServer::UiServer(const QString &address, QObject *parent):
+    QObject(parent),
+    d_ptr(new UiServerPrivate(address, this))
+{
+    m_instance = this;
+
+    qmlRegisterType<SignOnUi::RequestHandler>("Ubuntu.OnlineAccounts.Plugin",
+                                              1, 0, "RequestHandler");
+}
+
+UiServer::~UiServer()
+{
+    m_instance = 0;
+}
+
+UiServer *UiServer::instance()
+{
+    return m_instance;
+}
+
+bool UiServer::init()
+{
+    Q_D(UiServer);
+    return d->init();
+}
+
+void UiServer::registerHandler(SignOnUi::RequestHandler *handler)
+{
+    Q_D(UiServer);
+
+    QVariantMap operation;
+    operation.insert(OAU_OPERATION_CODE,
+                     OAU_OPERATION_CODE_REGISTER_HANDLER);
+    operation.insert(OAU_OPERATION_HANDLER_ID, handler->matchId());
+    d->sendOperation(operation);
+}
+
+#include "ui-server.moc"
 
=== added file 'online-accounts-ui/ui-server.h'
--- online-accounts-ui/ui-server.h	1970-01-01 00:00:00 +0000
+++ online-accounts-ui/ui-server.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef OAU_UI_SERVER_H
+#define OAU_UI_SERVER_H
+
+#include <QObject>
+#include <QVariantMap>
+
+namespace SignOnUi {
+class RequestHandler;
+}
+
+namespace OnlineAccountsUi {
+
+class UiServerPrivate;
+class UiServer: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit UiServer(const QString &address, QObject *parent = 0);
+    ~UiServer();
+
+    static UiServer *instance();
+
+    bool init();
+    void registerHandler(SignOnUi::RequestHandler *handler);
+
+Q_SIGNALS:
+    void finished();
+
+private:
+    UiServerPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(UiServer)
+};
+
+} // namespace
+
+#endif // OAU_UI_SERVER_H
 
=== modified file 'online-accounts-ui/ui.qrc'
--- src/ui.qrc	2014-03-19 12:14:14 +0000
+++ online-accounts-ui/ui.qrc	2014-08-18 13:33:35 +0000
@@ -1,17 +1,8 @@
 <!DOCTYPE RCC><RCC version="1.0">
 <qresource>
     <file>qml/AccountCreationPage.qml</file>
-    <file>qml/AccountEditPage.qml</file>
-    <file>qml/AccountItem.qml</file>
-    <file>qml/AccountsPage.qml</file>
-    <file>qml/AddAccountLabel.qml</file>
     <file>qml/AuthorizationPage.qml</file>
-    <file>qml/MainPage.qml</file>
-    <file>qml/NewAccountPage.qml</file>
-    <file>qml/NoAccountsPage.qml</file>
-    <file>qml/NormalStartupPage.qml</file>
-    <file>qml/ProviderPluginList.qml</file>
     <file>qml/ProviderRequest.qml</file>
-    <file>qml/ProvidersList.qml</file>
+    <file>qml/SignOnUiPage.qml</file>
 </qresource>
 </RCC>
 
=== renamed file 'src/qml/AccountEditPage.qml' => 'system-settings-plugin/AccountEditPage.qml'
--- src/qml/AccountEditPage.qml	2014-03-19 12:14:14 +0000
+++ system-settings-plugin/AccountEditPage.qml	2014-08-18 13:33:35 +0000
@@ -19,6 +19,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1
 import Ubuntu.OnlineAccounts 0.1
+import Ubuntu.OnlineAccounts.Plugin 1.0
 
 Page {
     id: root
@@ -34,26 +35,9 @@
         objectHandle: accountHandle
     }
 
-    Loader {
-        id: loader
-        property var account: account
-
-        anchors.fill: parent
-        source: localQmlPluginPath + account.provider.id + "/Main.qml"
-
-        onStatusChanged: {
-            if (loader.status == Loader.Error) {
-                loader.source = systemQmlPluginPath + account.provider.id + "/Main.qml"
-            }
-        }
-
-
-        Connections {
-            target: loader.item
-            onFinished: {
-                console.log("====== PLUGIN FINISHED ======")
-                root.finished()
-            }
+    Options {
+        onFinished: {
+            root.finished()
         }
     }
 }
 
=== renamed file 'src/qml/AccountItem.qml' => 'system-settings-plugin/AccountItem.qml'
=== renamed file 'src/qml/AccountsPage.qml' => 'system-settings-plugin/AccountsPage.qml'
=== renamed file 'src/qml/AddAccountLabel.qml' => 'system-settings-plugin/AddAccountLabel.qml'
=== renamed file 'src/qml/MainPage.qml' => 'system-settings-plugin/MainPage.qml'
--- src/qml/MainPage.qml	2014-05-29 21:14:11 +0000
+++ system-settings-plugin/MainPage.qml	2014-08-18 13:33:35 +0000
@@ -17,52 +17,36 @@
  */
 
 import QtQuick 2.0
+import SystemSettings 1.0
 import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
 import Ubuntu.OnlineAccounts 0.1
 
-MainView {
+ItemPage {
     id: root
-    width: units.gu(48)
-    height: units.gu(60)
-    useDeprecatedToolbar: false
-
-    Component.onCompleted: {
-        i18n.domain = "ubuntu-system-settings-online-accounts"
-        pageStack.push(mainPage)
-    }
-
-    PageStack {
-        id: pageStack
-
-        Page {
-            id: mainPage
-            title: i18n.tr("Accounts")
-            tools: ToolbarItems {
-                back: ActionItem {
-                    action: Action {
-                        iconName: "back"
-                        onTriggered: mainWindow.close()
-                    }
-                }
-            }
-
-            Loader {
-                id: loader
-                anchors.fill: parent
-                sourceComponent: pluginOptions.provider ? accountCreationPage : normalStartupPage
-            }
-        }
-    }
-
-    Component {
-        id: normalStartupPage
-        NormalStartupPage {}
-    }
-
-    Component {
-        id: accountCreationPage
-        AccountCreationPage {
-            providerId: pluginOptions.provider
-        }
-    }
-}
+    objectName: "accountsPage"
+
+    title: i18n.tr("Accounts")
+
+    property Item flickable: accountsPage.visible ? accountsPage : noAccountsPage
+
+    AccountServiceModel {
+        id: accountsModel
+        service: "global"
+        includeDisabled: true
+    }
+    
+    AccountsPage {
+        id: accountsPage
+        anchors.fill: parent
+        accountsModel: accountsModel
+        visible: accountsModel.count > 0
+    }
+    
+    NoAccountsPage {
+        id: noAccountsPage
+        anchors.fill: parent
+        accountsModel: accountsModel
+        visible:!accountsPage.visible
+    }
+}
 \ No newline at end of file
 
=== renamed file 'src/qml/NewAccountPage.qml' => 'system-settings-plugin/NewAccountPage.qml'
--- src/qml/NewAccountPage.qml	2013-10-17 11:08:57 +0000
+++ system-settings-plugin/NewAccountPage.qml	2014-08-18 13:33:35 +0000
@@ -29,8 +29,6 @@
 
         ProviderPluginList {
             onCreationFinished: {
-                // pop the creation page and this page (go back to parent page)
-                pageStack.pop()
                 pageStack.pop()
             }
         }
 
=== renamed file 'src/qml/NoAccountsPage.qml' => 'system-settings-plugin/NoAccountsPage.qml'
=== renamed file 'src/qml/NormalStartupPage.qml' => 'system-settings-plugin/NormalStartupPage.qml'
=== renamed file 'src/qml/ProviderPluginList.qml' => 'system-settings-plugin/ProviderPluginList.qml'
--- src/qml/ProviderPluginList.qml	2013-10-17 11:08:57 +0000
+++ system-settings-plugin/ProviderPluginList.qml	2014-08-18 13:33:35 +0000
@@ -18,25 +18,29 @@
 
 import QtQuick 2.0
 import Ubuntu.Components 0.1
+import Ubuntu.OnlineAccounts.Client 0.1
 
 ProvidersList {
     id: root
 
-    property variant __creationPage: null
+    property bool __processing: false
 
     signal creationFinished
 
+    Setup {
+        id: setup
+        applicationId: "system-settings"
+        onFinished: {
+            __processing = false
+            creationFinished()
+        }
+    }
+
     onProviderClicked: {
-        __creationPage = accountCreationPage.createObject(null, {
-            "providerId": providerId })
-        __creationPage.finished.connect(__onCreationFinished)
-        pageStack.push(__creationPage)
-    }
-
-    function __onCreationFinished() {
-        __creationPage.destroy(1000)
-        __creationPage.finished.disconnect(__onCreationFinished)
-        __creationPage = null
-        creationFinished()
+        if (!__processing) {
+            __processing = true
+            setup.providerId = providerId
+            setup.exec()
+        }
     }
 }
 
=== renamed file 'src/qml/ProvidersList.qml' => 'system-settings-plugin/ProvidersList.qml'
=== modified file 'system-settings-plugin/online-accounts.settings'
--- system-settings-plugin/online-accounts.settings	2013-09-09 10:56:53 +0000
+++ system-settings-plugin/online-accounts.settings	2014-08-18 13:33:35 +0000
@@ -11,5 +11,5 @@
     ],
     "has-dynamic-keywords": true,
     "has-dynamic-visibility": false,
-    "plugin": "online-accounts"
+    "page-component": "MainPage.qml"
 }
 
=== removed file 'system-settings-plugin/plugin.cpp'
--- system-settings-plugin/plugin.cpp	2014-05-30 08:55:40 +0000
+++ system-settings-plugin/plugin.cpp	1970-01-01 00:00:00 +0000
@@ -1,89 +0,0 @@
-/*
- * Copyright (C) 2013 Canonical Ltd.
- *
- * Contact: Alberto Mardegan <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, 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 warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "plugin.h"
-
-#include <OnlineAccountsClient/Setup>
-#include <QDebug>
-#include <QStringList>
-#include <SystemSettings/ItemBase>
-
-using namespace SystemSettings;
-
-class Item: public ItemBase
-{
-    Q_OBJECT
-
-public:
-    Item(const QVariantMap &staticData, QObject *parent = 0);
-    ~Item();
-
-    QQmlComponent *pageComponent(QQmlEngine *engine,
-                                 QObject *parent = 0) Q_DECL_OVERRIDE;
-
-private Q_SLOTS:
-    void onFinished();
-
-private:
-    OnlineAccountsClient::Setup m_setup;
-    bool m_isOpen;
-};
-
-Item::Item(const QVariantMap &staticData, QObject *parent):
-    ItemBase(staticData, parent),
-    m_isOpen(false)
-{
-    QObject::connect(&m_setup, SIGNAL(finished()),
-                     this, SLOT(onFinished()));
-}
-
-Item::~Item()
-{
-}
-
-QQmlComponent *Item::pageComponent(QQmlEngine *engine,
-                                   QObject *parent)
-{
-    Q_UNUSED(engine);
-    Q_UNUSED(parent);
-
-    if (!m_isOpen) {
-        qDebug() << "Opening Online Accounts";
-        m_isOpen = true;
-        m_setup.exec();
-    }
-    return 0;
-}
-
-void Item::onFinished()
-{
-    m_isOpen = false;
-}
-
-Plugin::Plugin():
-    QObject()
-{
-}
-
-ItemBase *Plugin::createItem(const QVariantMap &staticData,
-                             QObject *parent)
-{
-    return new Item(staticData, parent);
-}
-
-#include "plugin.moc"
 
=== removed file 'system-settings-plugin/plugin.h'
--- system-settings-plugin/plugin.h	2013-09-09 10:56:53 +0000
+++ system-settings-plugin/plugin.h	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2013 Canonical Ltd.
- *
- * Contact: Alberto Mardegan <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 3, 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 warranties of
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef ONLINE_ACCOUNTS_SYSTEM_SETTINGS_PLUGIN_H
-#define ONLINE_ACCOUNTS_SYSTEM_SETTINGS_PLUGIN_H
-
-#include <QObject>
-#include <SystemSettings/PluginInterface>
-
-class Plugin: public QObject, public SystemSettings::PluginInterface
-{
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID "com.ubuntu.SystemSettings.PluginInterface")
-    Q_INTERFACES(SystemSettings::PluginInterface)
-
-public:
-    Plugin();
-
-    SystemSettings::ItemBase *createItem(const QVariantMap &staticData,
-                                         QObject *parent = 0);
-};
-
-#endif // ONLINE_ACCOUNTS_SYSTEM_SETTINGS_PLUGIN_H
 
=== modified file 'system-settings-plugin/system-settings-plugin.pro'
--- system-settings-plugin/system-settings-plugin.pro	2013-09-09 10:56:53 +0000
+++ system-settings-plugin/system-settings-plugin.pro	2014-08-18 13:33:35 +0000
@@ -1,41 +1,28 @@
 include(../common-project-config.pri)
 include($${TOP_SRC_DIR}/common-vars.pri)
 
-TEMPLATE = lib
-TARGET = online-accounts
-
-CONFIG += \
-    link_pkgconfig \
-    plugin \
-    qt
-
-QT += \
-    core \
-    qml
-
-PKGCONFIG += \
-    SystemSettings
-
-LIBS += -lonline-accounts-client
-QMAKE_LIBDIR += $${TOP_BUILD_DIR}/client/OnlineAccountsClient
-INCLUDEPATH += \
-    $${TOP_SRC_DIR}/client \
-    /usr/include
-
-SOURCES += \
-    plugin.cpp
-
-HEADERS += \
-    plugin.h
+TEMPLATE=aux
+
+QML_SOURCES = \
+    AccountEditPage.qml \
+    AccountItem.qml \
+    AccountsPage.qml \
+    AddAccountLabel.qml \
+    MainPage.qml \
+    NewAccountPage.qml \
+    NoAccountsPage.qml \
+    NormalStartupPage.qml \
+    ProviderPluginList.qml \
+    ProvidersList.qml
 
 settings.files = online-accounts.settings
 settings.path = $${PLUGIN_MANIFEST_DIR}
 INSTALLS += settings
 
-target.path = $${PLUGIN_MODULE_DIR}
-INSTALLS += target
-
 image.files = settings-accounts.svg
 image.path = $${PLUGIN_MANIFEST_DIR}/icons
 INSTALLS += image
 
+qml.files = $${QML_SOURCES}
+qml.path = $${PLUGIN_QML_DIR}/online-accounts
+INSTALLS += qml
 
=== modified file 'tests/client/tst_client.cpp'
--- tests/client/tst_client.cpp	2014-03-19 12:14:14 +0000
+++ tests/client/tst_client.cpp	2014-08-18 13:33:35 +0000
@@ -20,7 +20,7 @@
  * <http://www.gnu.org/licenses/>.
  */
 
-#include "src/globals.h"
+#include "online-accounts-ui/globals.h"
 
 #include <OnlineAccountsClient/Setup>
 #include <QDBusConnection>
 
=== modified file 'tests/client/tst_qml_client.cpp'
--- tests/client/tst_qml_client.cpp	2014-03-19 12:14:14 +0000
+++ tests/client/tst_qml_client.cpp	2014-08-18 13:33:35 +0000
@@ -20,7 +20,7 @@
  * <http://www.gnu.org/licenses/>.
  */
 
-#include "src/globals.h"
+#include "online-accounts-ui/globals.h"
 
 #include <QDBusConnection>
 #include <QDebug>
 
=== added directory 'tests/online-accounts-service'
=== added file 'tests/online-accounts-service/online-accounts-service.pro'
--- tests/online-accounts-service/online-accounts-service.pro	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-service/online-accounts-service.pro	2014-08-18 13:33:35 +0000
@@ -0,0 +1,4 @@
+TEMPLATE = subdirs
+SUBDIRS = \
+    tst_inactivity_timer.pro \
+    tst_service.pro
 
=== renamed file 'tests/online-accounts-ui/tst_inactivity_timer.cpp' => 'tests/online-accounts-service/tst_inactivity_timer.cpp'
=== renamed file 'tests/online-accounts-ui/tst_inactivity_timer.pro' => 'tests/online-accounts-service/tst_inactivity_timer.pro'
--- tests/online-accounts-ui/tst_inactivity_timer.pro	2014-03-07 07:44:07 +0000
+++ tests/online-accounts-service/tst_inactivity_timer.pro	2014-08-18 13:33:35 +0000
@@ -9,15 +9,19 @@
     core \
     testlib
 
+ONLINE_ACCOUNTS_SERVICE_DIR = $${TOP_SRC_DIR}/online-accounts-service
+COMMON_SRC_DIR = $${TOP_SRC_DIR}/online-accounts-ui
+
 SOURCES += \
-    $${TOP_SRC_DIR}/src/inactivity-timer.cpp \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/inactivity-timer.cpp \
     tst_inactivity_timer.cpp
 
 HEADERS += \
-    $${TOP_SRC_DIR}/src/inactivity-timer.h
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/inactivity-timer.h
 
 INCLUDEPATH += \
-    $${TOP_SRC_DIR}/src
+    $${COMMON_SRC_DIR} \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}
 
 check.commands = "xvfb-run -s '-screen 0 640x480x24' -a ./$${TARGET}"
 check.depends = $${TARGET}
 
=== renamed file 'tests/online-accounts-ui/tst_service.cpp' => 'tests/online-accounts-service/tst_service.cpp'
--- tests/online-accounts-ui/tst_service.cpp	2014-04-29 12:11:55 +0000
+++ tests/online-accounts-service/tst_service.cpp	2014-08-18 13:33:35 +0000
@@ -22,7 +22,7 @@
 #include "request.h"
 #include "request-manager.h"
 #include "service.h"
-#include "window-watcher.h"
+#include "ui-proxy.h"
 
 #include <QDBusArgument>
 #include <QDBusConnection>
@@ -38,58 +38,12 @@
 
 using namespace OnlineAccountsUi;
 
-static const QString keyTimeout(QStringLiteral("timeout"));
-static const QString keyFail(QStringLiteral("fail"));
-
 #define P2P_SOCKET "unix:path=/tmp/tst_service_%1"
 #define TEST_SERVICE_NAME \
     QStringLiteral("com.ubuntu.OnlineAccountsUi.Test")
 #define TEST_OBJECT_PATH QStringLiteral("/")
 
-class TestRequest: public Request
-{
-    Q_OBJECT
-
-public:
-    TestRequest(const QDBusConnection &connection,
-                const QDBusMessage &message,
-                const QVariantMap &parameters,
-                QObject *parent = 0):
-        Request(connection, message, parameters, parent)
-    {
-        m_timer.setSingleShot(true);
-        m_timer.setInterval(parameters.value(keyTimeout).toInt());
-        QObject::connect(&m_timer, SIGNAL(timeout()),
-                         this, SLOT(onTimeout()));
-    }
-
-    void start() Q_DECL_OVERRIDE {
-        Request::start();
-        QWindow *window = new QWindow;
-        setWindow(window);
-        m_timer.start();
-    }
-
-private Q_SLOTS:
-    void onTimeout() {
-        if (parameters().contains(keyFail)) {
-            fail(parameters().value(keyFail).toString(), "Request failed");
-        } else {
-            setResult(parameters());
-        }
-    }
-
-private:
-    QTimer m_timer;
-};
-
-Request *Request::newRequest(const QDBusConnection &connection,
-                             const QDBusMessage &message,
-                             const QVariantMap &parameters,
-                             QObject *parent)
-{
-    return new TestRequest(connection, message, parameters, parent);
-}
+QList<UiProxyPrivate *> m_uiProxies;
 
 class RequestReply: public QDBusPendingCallWatcher
 {
@@ -107,6 +61,7 @@
     bool isError() const { return m_isError; }
     QVariantMap reply() const { return m_reply; }
     QString errorName() const { return m_errorName; }
+    QString errorMessage() const { return m_errorMessage; }
 
 private Q_SLOTS:
     void onFinished() {
@@ -114,6 +69,7 @@
         if (reply.isError()) {
             m_isError = true;
             m_errorName = reply.error().name();
+            m_errorMessage = reply.error().message();
         } else {
             m_reply = qdbus_cast<QVariantMap>(reply.argumentAt(0).
                                               value<QDBusArgument>());
@@ -128,6 +84,7 @@
     bool m_isError;
     QVariantMap m_reply;
     QString m_errorName;
+    QString m_errorMessage;
 };
 
 class ServiceTest: public QObject
@@ -154,8 +111,6 @@
     void testResults();
     void testFailure();
     void testIdle();
-    void testWindow();
-    void testWindowTransiency();
 
 protected Q_SLOTS:
     void onNewConnection(const QDBusConnection &connection);
@@ -166,6 +121,73 @@
     QDBusConnection m_connection;
 };
 
+/* Mocking UiProxy { */
+namespace OnlineAccountsUi {
+
+class UiProxyPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(UiProxy)
+
+public:
+    UiProxyPrivate(UiProxy *uiProxy):
+        QObject(uiProxy),
+        m_initCount(0),
+        m_initReply(true),
+        q_ptr(uiProxy)
+    {
+    }
+    ~UiProxyPrivate() {};
+
+    void emitFinished() { Q_EMIT q_ptr->finished(); }
+
+Q_SIGNALS:
+    void handleRequestCalled();
+
+public:
+    int m_initCount;
+    bool m_initReply;
+    QList<Request*> m_requests;
+    QVariantMap m_expectedHasHandlerFor;
+    mutable UiProxy *q_ptr;
+};
+
+} // namespace
+
+UiProxy::UiProxy(pid_t, QObject *parent):
+    QObject(parent),
+    d_ptr(new UiProxyPrivate(this))
+{
+    m_uiProxies.append(d_ptr);
+}
+
+UiProxy::~UiProxy()
+{
+    m_uiProxies.removeOne(d_ptr);
+}
+
+bool UiProxy::init()
+{
+    Q_D(UiProxy);
+    d->m_initCount++;
+    return d->m_initReply;
+}
+
+void UiProxy::handleRequest(Request *request)
+{
+    Q_D(UiProxy);
+    d->m_requests.append(request);
+    Q_EMIT d->handleRequestCalled();
+}
+
+bool UiProxy::hasHandlerFor(const QVariantMap &parameters)
+{
+    Q_D(UiProxy);
+    return parameters == d->m_expectedHasHandlerFor;
+}
+
+/* } mocking UiProxy */
+
 ServiceTest::ServiceTest():
     QObject(0),
     m_connection(QStringLiteral("uninitialized"))
@@ -205,30 +227,60 @@
 void ServiceTest::testResults()
 {
     QVariantMap parameters;
-    parameters.insert(keyTimeout, 10);
     parameters.insert("hello", QString("world"));
     RequestReply *call = sendRequest(parameters);
     QSignalSpy callFinished(call, SIGNAL(finished()));
 
+    QTRY_COMPARE(m_uiProxies.count(), 1);
+
+    UiProxyPrivate *proxy = m_uiProxies[0];
+    QCOMPARE(proxy->m_initCount, 1);
+    QCOMPARE(proxy->m_requests.count(), 1);
+
+    Request *request = proxy->m_requests.last();
+    QCOMPARE(request->parameters(), parameters);
+
+    request->setInProgress(true);
+    request->setResult(parameters);
+
     QVERIFY(callFinished.wait());
     QCOMPARE(call->isError(), false);
     QCOMPARE(call->reply(), parameters);
     delete call;
+
+    proxy->emitFinished();
+    QTRY_COMPARE(m_uiProxies.count(), 0);
 }
 
 void ServiceTest::testFailure()
 {
+    QVariantMap parameters;
+    parameters.insert("hi", "there");
+    RequestReply *call = sendRequest(parameters);
+    QSignalSpy callFinished(call, SIGNAL(finished()));
+
+    QTRY_COMPARE(m_uiProxies.count(), 1);
+
+    UiProxyPrivate *proxy = m_uiProxies[0];
+    QCOMPARE(proxy->m_initCount, 1);
+    QCOMPARE(proxy->m_requests.count(), 1);
+
+    Request *request = proxy->m_requests.last();
+    QCOMPARE(request->parameters(), parameters);
+
+    request->setInProgress(true);
     QString errorName("com.ubuntu.OnlineAccountsUi.BadLuck");
-    QVariantMap parameters;
-    parameters.insert(keyTimeout, 10);
-    parameters.insert("fail", errorName);
-    RequestReply *call = sendRequest(parameters);
-    QSignalSpy callFinished(call, SIGNAL(finished()));
+    QString errorMessage("really unlucky");
+    request->fail(errorName, errorMessage);
 
     QVERIFY(callFinished.wait());
     QCOMPARE(call->isError(), true);
     QCOMPARE(call->errorName(), errorName);
+    QCOMPARE(call->errorMessage(), errorMessage);
     delete call;
+
+    proxy->emitFinished();
+    QTRY_COMPARE(m_uiProxies.count(), 0);
 }
 
 void ServiceTest::testIdle()
@@ -238,65 +290,37 @@
     QSignalSpy isIdleChanged(&m_requestManager, SIGNAL(isIdleChanged()));
 
     QVariantMap parameters;
-    parameters.insert(keyTimeout, 10);
+    parameters.insert("time", "out");
     RequestReply *call = sendRequest(parameters);
     QSignalSpy callFinished(call, SIGNAL(finished()));
 
     QVERIFY(isIdleChanged.wait());
     QCOMPARE(m_requestManager.isIdle(), false);
-
-    /* the request will terminate after 10 milliseconds, so expect the service
+    isIdleChanged.clear();
+
+    QTRY_COMPARE(m_uiProxies.count(), 1);
+
+    UiProxyPrivate *proxy = m_uiProxies[0];
+    QCOMPARE(proxy->m_initCount, 1);
+    QCOMPARE(proxy->m_requests.count(), 1);
+
+    Request *request = proxy->m_requests.last();
+    QCOMPARE(request->parameters(), parameters);
+
+    request->setInProgress(true);
+    request->setResult(parameters);
+
+    /* the request will terminate, so expect the service
      * to be idle again */
-    QVERIFY(isIdleChanged.wait());
+    QTRY_COMPARE(isIdleChanged.count(), 1);
     QCOMPARE(m_requestManager.isIdle(), true);
 
     QVERIFY(callFinished.wait());
     QCOMPARE(call->isError(), false);
     delete call;
-}
-
-void ServiceTest::testWindow()
-{
-    QVariantMap parameters;
-    parameters.insert(keyTimeout, 10);
-    RequestReply *call = sendRequest(parameters);
-    QSignalSpy callFinished(call, SIGNAL(finished()));
-    QSignalSpy windowShown(WindowWatcher::instance(),
-                           SIGNAL(windowShown(QObject*)));
-
-    QVERIFY(windowShown.wait());
-    QWindow *window =
-        qobject_cast<QWindow*>(windowShown.at(0).at(0).value<QObject*>());
-    QVERIFY(window->property("transientParent").isNull());
-    QVERIFY(callFinished.wait());
-    QCOMPARE(call->isError(), false);
-    delete call;
-
-    QCOMPARE(windowShown.count(), 1);
-}
-
-void ServiceTest::testWindowTransiency()
-{
-    QVariantMap parameters;
-    parameters.insert(keyTimeout, 10);
-    parameters.insert(OAU_KEY_WINDOW_ID, 371);
-    RequestReply *call = sendRequest(parameters);
-    QSignalSpy callFinished(call, SIGNAL(finished()));
-    QSignalSpy windowShown(WindowWatcher::instance(),
-                           SIGNAL(windowShown(QObject*)));
-
-    QVERIFY(windowShown.wait());
-    QWindow *window =
-        qobject_cast<QWindow*>(windowShown.at(0).at(0).value<QObject*>());
-    QObject *transientParentObject =
-        window->property("transientParent").value<QObject*>();
-    QWindow *transientParent = qobject_cast<QWindow*>(transientParentObject);
-    QCOMPARE(transientParent->property("winId").toUInt(), uint(371));
-    QVERIFY(callFinished.wait());
-    QCOMPARE(call->isError(), false);
-    delete call;
-
-    QCOMPARE(windowShown.count(), 1);
+
+    proxy->emitFinished();
+    QTRY_COMPARE(m_uiProxies.count(), 0);
 }
 
 QTEST_MAIN(ServiceTest);
 
=== renamed file 'tests/online-accounts-ui/tst_service.pro' => 'tests/online-accounts-service/tst_service.pro'
--- tests/online-accounts-ui/tst_service.pro	2014-04-29 12:11:55 +0000
+++ tests/online-accounts-service/tst_service.pro	2014-08-18 13:33:35 +0000
@@ -13,23 +13,26 @@
 DEFINES += \
     NO_REQUEST_FACTORY
 
+ONLINE_ACCOUNTS_SERVICE_DIR = $${TOP_SRC_DIR}/online-accounts-service
+COMMON_SRC_DIR = $${TOP_SRC_DIR}/online-accounts-ui
+
 SOURCES += \
-    $${TOP_BUILD_DIR}/src/onlineaccountsui_adaptor.cpp \
-    $${TOP_SRC_DIR}/src/request.cpp \
-    $${TOP_SRC_DIR}/src/request-manager.cpp \
-    $${TOP_SRC_DIR}/src/service.cpp \
-    mock/qwindow.cpp \
+    $${TOP_BUILD_DIR}/online-accounts-service/onlineaccountsui_adaptor.cpp \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/request.cpp \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/request-manager.cpp \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/service.cpp \
     tst_service.cpp
 
 HEADERS += \
-    $${TOP_BUILD_DIR}/src/onlineaccountsui_adaptor.h \
-    $${TOP_SRC_DIR}/src/request.h \
-    $${TOP_SRC_DIR}/src/request-manager.h \
-    $${TOP_SRC_DIR}/src/service.h \
-    window-watcher.h
+    $${TOP_BUILD_DIR}/online-accounts-service/onlineaccountsui_adaptor.h \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/request.h \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/request-manager.h \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/service.h \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR}/ui-proxy.h \
 
 INCLUDEPATH += \
-    $${TOP_SRC_DIR}/src
+    $${ONLINE_ACCOUNTS_SERVICE_DIR} \
+    $${COMMON_SRC_DIR}
 
 check.commands = "xvfb-run -s '-screen 0 640x480x24' -a dbus-test-runner -t ./$${TARGET}"
 check.depends = $${TARGET}
 
=== added file 'tests/online-accounts-ui/data/com.ubuntu.tests_application.application'
--- tests/online-accounts-ui/data/com.ubuntu.tests_application.application	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/data/com.ubuntu.tests_application.application	2014-08-18 13:33:35 +0000
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<application id="com.ubuntu.tests_application">
+  <description>Mailer</description>
+  <translations>mailer-catalog</translations>
+  <desktop-entry>mailer.desktop</desktop-entry>
+
+  <service-types>
+    <service-type id="e-mail">
+      <description>Mailer can retrieve your e-mails</description>
+    </service-type>
+  </service-types>
+
+  <services>
+    <service id="coolshare">
+      <description>Mailer can even share stuff on CoolShare</description>
+    </service>
+  </services>
+	<profile>com.ubuntu.tests_application_0.3</profile>
+</application>
 
=== added file 'tests/online-accounts-ui/mock/notification-mock.cpp'
--- tests/online-accounts-ui/mock/notification-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/notification-mock.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "notification-mock.h"
+
+#include <QByteArray>
+#include <QDebug>
+#include <QString>
+
+using namespace OnlineAccountsUi;
+
+QList<Notification*> NotificationPrivate::allNotifications;
+
+NotificationPrivate::NotificationPrivate(const QString &summary,
+                                         const QString &body,
+                                         Notification *notification):
+    QObject(notification),
+    m_summary(summary),
+    m_body(body),
+    q_ptr(notification)
+{
+    allNotifications.append(notification);
+}
+
+NotificationPrivate::~NotificationPrivate()
+{
+    allNotifications.removeAll(q_ptr);
+}
+
+void NotificationPrivate::invokeAction(const QString &action)
+{
+    Q_Q(Notification);
+    Q_EMIT q->actionInvoked(action);
+}
+
+Notification::Notification(const QString &summary,
+                           const QString &body,
+                           QObject *parent):
+    QObject(parent),
+    d_ptr(new NotificationPrivate(summary, body, this))
+{
+}
+
+Notification::~Notification()
+{
+}
+
+void Notification::addAction(const QString &action, const QString &label)
+{
+    Q_D(Notification);
+    d->m_actions.append(ActionPair(action, label));
+}
+
+void Notification::setSnapDecision(bool snapDecision)
+{
+    Q_D(Notification);
+    d->m_isSnapDecision = snapDecision;
+}
+
+void Notification::show()
+{
+    Q_D(Notification);
+    Q_EMIT d->showCalled();
+}
 
=== added file 'tests/online-accounts-ui/mock/notification-mock.h'
--- tests/online-accounts-ui/mock/notification-mock.h	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/notification-mock.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MOCK_NOTIFICATiON_H
+#define MOCK_NOTIFICATiON_H
+
+#include "notification.h"
+
+#include <QByteArray>
+#include <QList>
+#include <QPair>
+#include <QString>
+
+using namespace OnlineAccountsUi;
+
+namespace OnlineAccountsUi {
+
+typedef QPair<QString,QString> ActionPair;
+
+class NotificationPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(Notification)
+
+public:
+    NotificationPrivate(const QString &summary,
+                        const QString &body,
+                        Notification *notification);
+    ~NotificationPrivate();
+    static NotificationPrivate *mocked(Notification *n) { return n->d_ptr; }
+
+    static QList<Notification *> allNotifications;
+
+    void invokeAction(const QString &action);
+
+Q_SIGNALS:
+    void showCalled();
+
+public:
+    QString m_summary;
+    QString m_body;
+    QList<ActionPair> m_actions;
+    bool m_isSnapDecision;
+    mutable Notification *q_ptr;
+};
+
+} // namespace
+
+#endif // MOCK_NOTIFICATiON_H
 
=== added file 'tests/online-accounts-ui/mock/request-mock.cpp'
--- tests/online-accounts-ui/mock/request-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/request-mock.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "globals.h"
+#include "request-mock.h"
+
+#include <QDebug>
+
+using namespace OnlineAccountsUi;
+
+RequestPrivate::RequestPrivate(const QString &interface,
+                               int id,
+                               const QString &clientProfile,
+                               const QVariantMap &parameters,
+                               Request *request):
+    QObject(request),
+    q_ptr(request),
+    m_parameters(parameters),
+    m_clientApparmorProfile(clientProfile),
+    m_window(0),
+    m_inProgress(false)
+{
+    Q_UNUSED(interface);
+    Q_UNUSED(id);
+}
+
+RequestPrivate::~RequestPrivate()
+{
+}
+
+Request::Request(const QString &interface,
+                 int id,
+                 const QString &clientProfile,
+                 const QVariantMap &parameters,
+                 QObject *parent):
+    QObject(parent),
+    d_ptr(new RequestPrivate(interface, id, clientProfile, parameters, this))
+{
+}
+
+Request::~Request()
+{
+}
+
+void Request::setWindow(QWindow *window)
+{
+    Q_D(Request);
+    Q_EMIT d->setWindowCalled(window);
+}
+
+WId Request::windowId() const
+{
+    Q_D(const Request);
+    return d->m_parameters[OAU_KEY_WINDOW_ID].toUInt();
+}
+
+bool Request::isInProgress() const
+{
+    Q_D(const Request);
+    return d->m_inProgress;
+}
+
+const QVariantMap &Request::parameters() const
+{
+    Q_D(const Request);
+    return d->m_parameters;
+}
+
+QString Request::clientApparmorProfile() const
+{
+    Q_D(const Request);
+    return d->m_clientApparmorProfile;
+}
+
+QWindow *Request::window() const
+{
+    Q_D(const Request);
+    return d->m_window;
+}
+
+void Request::start()
+{
+    Q_D(Request);
+    if (d->m_inProgress) {
+        qWarning() << "Request already started!";
+        return;
+    }
+    d->m_inProgress = true;
+}
+
+void Request::cancel()
+{
+    setCanceled();
+}
+
+void Request::fail(const QString &name, const QString &message)
+{
+    Q_D(Request);
+    Q_EMIT d->failCalled(name, message);
+
+    Q_EMIT completed();
+}
+
+void Request::setCanceled()
+{
+    Q_D(Request);
+    if (d->m_inProgress) {
+        fail(OAU_ERROR_USER_CANCELED, QStringLiteral("Canceled"));
+        d->m_inProgress = false;
+    }
+}
+
+void Request::setResult(const QVariantMap &result)
+{
+    Q_D(Request);
+    if (d->m_inProgress) {
+        Q_EMIT d->setResultCalled(result);
+
+        Q_EMIT completed();
+        d->m_inProgress = false;
+    }
+}
 
=== added file 'tests/online-accounts-ui/mock/request-mock.h'
--- tests/online-accounts-ui/mock/request-mock.h	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/request-mock.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MOCK_REQUEST_H
+#define MOCK_REQUEST_H
+
+#include "request.h"
+
+#include <QObject>
+#include <QString>
+#include <QVariantMap>
+
+namespace OnlineAccountsUi {
+
+class RequestPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(Request)
+
+public:
+    RequestPrivate(const QString &interface,
+                   int id,
+                   const QString &clientProfile,
+                   const QVariantMap &parameters,
+                   Request *request);
+    ~RequestPrivate();
+    static RequestPrivate *mocked(Request *r) { return r->d_ptr; }
+
+Q_SIGNALS:
+    void setWindowCalled(QWindow *);
+    void failCalled(const QString &name, const QString &message);
+    void setResultCalled(const QVariantMap &result);
+
+private:
+    mutable Request *q_ptr;
+    QVariantMap m_parameters;
+    QString m_clientApparmorProfile;
+    QWindow *m_window;
+    bool m_inProgress;
+};
+
+} // namespace
+
+#endif // MOCK_REQUEST_H
 
=== added file 'tests/online-accounts-ui/mock/ui-server-mock.cpp'
--- tests/online-accounts-ui/mock/ui-server-mock.cpp	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/ui-server-mock.cpp	2014-08-18 13:33:35 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ui-server-mock.h"
+
+#include <QDebug>
+
+using namespace OnlineAccountsUi;
+
+static UiServer *m_instance = 0;
+
+UiServerPrivate::UiServerPrivate(const QString &address,
+                                 UiServer *server):
+    QObject(server),
+    q_ptr(server),
+    m_address(address)
+{
+}
+
+UiServerPrivate::~UiServerPrivate()
+{
+}
+
+UiServer::UiServer(const QString &address,
+                   QObject *parent):
+    QObject(parent),
+    d_ptr(new UiServerPrivate(address, this))
+{
+    m_instance = this;
+}
+
+UiServer::~UiServer()
+{
+    m_instance = 0;
+}
+
+UiServer *UiServer::instance()
+{
+    return m_instance;
+}
+
+bool UiServer::init()
+{
+    return true;
+}
+
+void UiServer::registerHandler(SignOnUi::RequestHandler *handler)
+{
+    Q_D(UiServer);
+    Q_EMIT d->registerHandlerCalled(handler);
+}
 
=== added file 'tests/online-accounts-ui/mock/ui-server-mock.h'
--- tests/online-accounts-ui/mock/ui-server-mock.h	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/mock/ui-server-mock.h	2014-08-18 13:33:35 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * This file is part of online-accounts-ui
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MOCK_UI_SERVER_H
+#define MOCK_UI_SERVER_H
+
+#include "ui-server.h"
+
+#include <QObject>
+#include <QString>
+
+namespace OnlineAccountsUi {
+
+class UiServerPrivate: public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PUBLIC(UiServer)
+
+public:
+    UiServerPrivate(const QString &address, UiServer *pluginServer);
+    ~UiServerPrivate();
+    static UiServerPrivate *mocked(UiServer *r) { return r->d_ptr; }
+
+    void emitFinished() { Q_EMIT q_ptr->finished(); }
+
+Q_SIGNALS:
+    void registerHandlerCalled(SignOnUi::RequestHandler *handler);
+
+public:
+    mutable UiServer *q_ptr;
+    QString m_address;
+};
+
+} // namespace
+
+#endif // MOCK_UI_SERVER_H
 
=== added file 'tests/online-accounts-ui/online-accounts-ui.pri'
--- tests/online-accounts-ui/online-accounts-ui.pri	1970-01-01 00:00:00 +0000
+++ tests/online-accounts-ui/online-accounts-ui.pri	2014-08-18 13:33:35 +0000
@@ -0,0 +1,18 @@
+include(../../common-project-config.pri)
+
+CONFIG += \
+    debug
+
+QT += \
+    core \
+    testlib
+
+DEFINES += \
+    DEBUG_ENABLED
+
+ONLINE_ACCOUNTS_UI_DIR = $${TOP_SRC_DIR}/online-accounts-ui
+COMMON_SRC_DIR = $${TOP_SRC_DIR}/online-accounts-ui
+
+INCLUDEPATH += \
+    $${ONLINE_ACCOUNTS_SERVICE_DIR} \
+    $${COMMON_SRC_DIR}
 
=== modified file 'tests/online-accounts-ui/online-accounts-ui.pro'
--- tests/online-accounts-ui/online-accounts-ui.pro	2014-06-05 13:28:30 +0000
+++ tests/online-accounts-ui/online-accounts-ui.pro	2014-08-18 13:33:35 +0000
@@ -3,6 +3,5 @@
     qml \
     tst_access_model.pro \
     tst_application_manager.pro \
-    tst_inactivity_timer.pro \
     tst_notification.pro \
-    tst_service.pro
+    tst_signonui_request.pro
 
=== modified file 'tests/online-accounts-ui/qml/Source/qmldir'
--- tests/online-accounts-ui/qml/Source/qmldir	2013-09-18 08:35:43 +0000
+++ tests/online-accounts-ui/qml/Source/qmldir	2014-08-18 13:33:35 +0000
@@ -1,2 +1,2 @@
 module Source
-AccountCreationPage 1.0 ../../../../src/qml/AccountCreationPage.qml
+AccountCreationPage 1.0 ../../../../online-accounts-ui/qml/AccountCreationPage.qml
 
=== modified file 'tests/online-accounts-ui/tst_access_model.pro'
--- tests/online-accounts-ui/tst_access_model.pro	2014-02-03 10:27:39 +0000
+++ tests/online-accounts-ui/tst_access_model.pro	2014-08-18 13:33:35 +0000
@@ -1,37 +1,30 @@
-include(../../common-project-config.pri)
+include(online-accounts-ui.pri)
 
 TARGET = tst_access_model
 
 CONFIG += \
-    debug \
     link_pkgconfig
 
 QT += \
-    core \
     dbus \
-    qml \
-    testlib
+    qml
 
 PKGCONFIG += \
     accounts-qt5
 
 DEFINES += \
-    DEBUG_ENABLED \
     TEST_DATA_DIR=\\\"$${PWD}/data\\\"
 
 SOURCES += \
-    $${TOP_SRC_DIR}/src/access-model.cpp \
-    $${TOP_SRC_DIR}/src/account-manager.cpp \
-    $${TOP_SRC_DIR}/src/debug.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/access-model.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/account-manager.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/debug.cpp \
     tst_access_model.cpp
 
 HEADERS += \
-    $${TOP_SRC_DIR}/src/access-model.h \
-    $${TOP_SRC_DIR}/src/account-manager.h \
-    $${TOP_SRC_DIR}/src/debug.h
-
-INCLUDEPATH += \
-    $${TOP_SRC_DIR}/src
+    $${ONLINE_ACCOUNTS_UI_DIR}/access-model.h \
+    $${ONLINE_ACCOUNTS_UI_DIR}/account-manager.h \
+    $${ONLINE_ACCOUNTS_UI_DIR}/debug.h
 
 check.commands = "xvfb-run -a dbus-test-runner -t ./$${TARGET}"
 check.depends = $${TARGET}
 
=== modified file 'tests/online-accounts-ui/tst_application_manager.pro'
--- tests/online-accounts-ui/tst_application_manager.pro	2014-05-14 13:31:42 +0000
+++ tests/online-accounts-ui/tst_application_manager.pro	2014-08-18 13:33:35 +0000
@@ -1,37 +1,30 @@
-include(../../common-project-config.pri)
+include(online-accounts-ui.pri)
 
 TARGET = tst_application_manager
 
 CONFIG += \
-    debug \
     link_pkgconfig
 
 QT += \
-    core \
     dbus \
-    qml \
-    testlib
+    qml
 
 PKGCONFIG += \
     accounts-qt5
 
 DEFINES += \
-    DEBUG_ENABLED \
     TEST_DATA_DIR=\\\"$${PWD}/data\\\"
 
 SOURCES += \
-    $${TOP_SRC_DIR}/src/application-manager.cpp \
-    $${TOP_SRC_DIR}/src/account-manager.cpp \
-    $${TOP_SRC_DIR}/src/debug.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/application-manager.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/account-manager.cpp \
+    $${ONLINE_ACCOUNTS_UI_DIR}/debug.cpp \
     tst_application_manager.cpp
 
 HEADERS += \
-    $${TOP_SRC_DIR}/src/application-manager.h \
-    $${TOP_SRC_DIR}/src/account-manager.h \
-    $${TOP_SRC_DIR}/src/debug.h
-
-INCLUDEPATH += \
-    $${TOP_SRC_DIR}/src
+    $${ONLINE_ACCOUNTS_UI_DIR}/application-manager.h \
+    $${ONLINE_ACCOUNTS_UI_DIR}/account-manager.h \
+    $${ONLINE_ACCOUNTS_UI_DIR}/debug.h
 
 check.commands = "xvfb-run -a dbus-test-runner -t ./$${TARGET}"
 check.depends = $${TARGET}
 
=== modified file 'tests/online-accounts-ui/tst_notification.cpp'
--- tests/online-accounts-ui/tst_notification.cpp	2014-06-05 13:28:30 +0000
+++ tests/online-accounts-ui/tst_notification.cpp	2014-08-18 13:33:35 +0000
@@ -26,6 +26,7 @@
 #include <QPair>
 #include <QSignalSpy>
 #include <QTest>
+#include <QVariantMap>
 #include <libnotify/notification.h>
 #include <libnotify/notify.h>
 
@@ -52,6 +53,7 @@
     QString summary;
     QString body;
     QList<ActionPair> actions;
+    QVariantMap hints;
     bool visible;
 
     MockNotification();
@@ -167,6 +169,22 @@
     callbackData.userData = user_data;
 }
 
+void notify_notification_set_hint(NotifyNotification *notification,
+                                  const char *key,
+                                  GVariant *value)
+{
+    MockNotification *mock =
+        reinterpret_cast<MockNotification*>(notification);
+    QVariant variant;
+    if (g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
+        variant = bool(g_variant_get_boolean(value));
+    } else {
+        /* Add support for any needed types */
+        qWarning() << "Unsupported variant type";
+    }
+    mock->hints.insert(QString::fromUtf8(key), variant);
+}
+
 /* End of mock code */
 
 class NotificationTest: public QObject
@@ -180,6 +198,7 @@
     void testInitialization();
     void testDestruction();
     void testContents();
+    void testSnapDecision();
     void testVisibility();
     void testClosing();
     void testActions();
@@ -220,6 +239,20 @@
     MockNotification *mock = *(notifications.begin());
     QCOMPARE(mock->summary, QString("Summary"));
     QCOMPARE(mock->body, QString("Body"));
+    QVERIFY(mock->hints.isEmpty());
+}
+
+void NotificationTest::testSnapDecision()
+{
+    Notification first("Summary", "Body");
+    MockNotification *mock = *(notifications.begin());
+    QVERIFY(mock->hints.isEmpty());
+
+    first.setSnapDecision(true);
+    QCOMPARE(mock->hints["x-canonical-snap-decisions"].toBool(), true);
+
+    first.setSnapDecision(false);
+    QCOMPARE(mock->hints["x-canonical-snap-decisions"].toBool(), false);
 }