Merge lp:~gerboland/miral/qt-bump-to-qtmir-529 into lp:miral

[Gerry Boland]

[miral-qt] Bump to rev 529 of qtmir

[Alan Griffiths (alan-griffiths)]

I wonder why "DBusFocusInfo *m_dbusFocusInfo;" isn't "DBusFocusInfo m_dbusFocusInfo;" (avoiding explicit memory management) but I guess this is the wrong project in which to ask that.

[Alan Griffiths (alan-griffiths)]

+ QRect inputBounds() const override { return QRect(0,0,10,10); }

Is this really an override? It seems to be missing in the MirSurfaceInterface base class.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

+ void inputBoundsChanged(const QRect &rect);

Neither the linker nor I can find the implementation.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

Hmm. A clean rebuild fixed those. (Is there a depends missing somewhere in CMakeLists.txt?)

review: Approve

[Gerry Boland (gerboland)]

> DBusFocusInfo *m_dbusFocusInfo
good point, I didn't see it as it landed while I was on hols!

Build fail - am surprised, I bumped the required unity-shell-application version to the correct one (19). It should have not tried to build unless you have libunity-api-dev version 7.116 already installed

=== modified file 'miral-qt/CMakeLists.txt'
--- miral-qt/CMakeLists.txt	2016-06-21 13:38:53 +0000
+++ miral-qt/CMakeLists.txt	2016-07-26 12:46:18 +0000
@@ -90,9 +90,8 @@
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
 pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=18)
-
-include_directories(${APPLICATION_API_INCLUDE_DIRS})
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=19)
+pkg_check_modules(CGMANAGER libcgmanager REQUIRED)
 
 add_definitions(-DMIR_REQUIRE_DEPRECATED_EVENT_OPT_IN=1)
 
 
=== modified file 'miral-qt/debian/control'
--- miral-qt/debian/control	2016-06-21 13:38:53 +0000
+++ miral-qt/debian/control	2016-07-26 12:46:18 +0000
@@ -6,6 +6,7 @@
                cmake-extras (>= 0.3),
                debhelper (>= 9),
                google-mock (>= 1.6.0+svn437),
+               libcgmanager-dev,
                libfontconfig1-dev,
                libgles2-mesa-dev,
                libglib2.0-dev,
@@ -22,7 +23,7 @@
                libubuntu-app-launch2-dev (>= 0.9),
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.114),
+               libunity-api-dev (>= 7.116),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,
@@ -93,7 +94,7 @@
 Conflicts: libqtmir,
            libunity-mir1,
 Provides: unity-application-impl,
-          unity-application-impl-17,
+          unity-application-impl-19,
 Description: Qt plugin for Unity specific Mir APIs
  QtMir provides Qt/QML bindings for Mir features that are exposed through the
  qtmir-desktop or qtmir-android QPA plugin such as Application management
 
=== modified file 'miral-qt/debian/gles-patches/convert-to-gles.patch'
--- miral-qt/debian/gles-patches/convert-to-gles.patch	2016-06-07 20:32:04 +0000
+++ miral-qt/debian/gles-patches/convert-to-gles.patch	2016-07-26 12:46:18 +0000
@@ -84,7 +84,7 @@
 -Conflicts: libqtmir,
 -           libunity-mir1,
 -Provides: unity-application-impl,
--          unity-application-impl-17,
+-          unity-application-impl-19,
 -Description: Qt plugin for Unity specific Mir APIs
 - QtMir provides Qt/QML bindings for Mir features that are exposed through the
 - qtmir-desktop or qtmir-android QPA plugin such as Application management
 
=== modified file 'miral-qt/src/modules/Unity/Application/CMakeLists.txt'
--- miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/CMakeLists.txt	2016-07-26 12:46:18 +0000
@@ -10,6 +10,7 @@
     ${MIRAL_QT_SOURCE_DIR}/src/platforms/mirserver
     ${MIRAL_QT_SOURCE_DIR}/src/common
     ${GSETTINGS_QT_INCLUDE_DIRS}
+    ${CGMANAGER_INCLUDE_DIRS}
 
     ${LTTNG_INCLUDE_DIRS}
     ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
@@ -25,12 +26,13 @@
 set(QMLMIRPLUGIN_SRC
     application_manager.cpp
     application.cpp
+    cgmanager.cpp
     ../../../common/abstractdbusservicemonitor.cpp
     ../../../common/debughelpers.cpp
+    dbusfocusinfo.cpp
     plugin.cpp
     dbuswindowstack.cpp
     mirsurfacemanager.cpp
-    ubuntukeyboardinfo.cpp
     mirfocuscontroller.cpp
     mirsurface.cpp
     mirsurfaceinterface.h
 
=== modified file 'miral-qt/src/modules/Unity/Application/application.cpp'
--- miral-qt/src/modules/Unity/Application/application.cpp	2016-06-21 13:38:53 +0000
+++ miral-qt/src/modules/Unity/Application/application.cpp	2016-07-26 12:46:18 +0000
@@ -18,6 +18,7 @@
 #include "application.h"
 #include "applicationinfo.h"
 #include "application_manager.h"
+#include "mirsurfaceinterface.h"
 #include "session.h"
 #include "sharedwakelock.h"
 #include "timer.h"
 
=== modified file 'miral-qt/src/modules/Unity/Application/application_manager.cpp'
--- miral-qt/src/modules/Unity/Application/application_manager.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/application_manager.cpp	2016-07-26 12:46:18 +0000
@@ -18,6 +18,7 @@
 #include "application_manager.h"
 #include "application.h"
 #include "applicationinfo.h"
+#include "dbusfocusinfo.h"
 #include "dbuswindowstack.h"
 #include "mirfocuscontroller.h"
 #include "session.h"
@@ -176,6 +177,7 @@
         const QSharedPointer<SettingsInterface>& settings,
         QObject *parent)
     : ApplicationManagerInterface(parent)
+    , m_dbusFocusInfo(new DBusFocusInfo(m_applications))
     , m_dbusWindowStack(new DBusWindowStack(this))
     , m_taskController(taskController)
     , m_procInfo(procInfo)
@@ -200,6 +202,7 @@
 ApplicationManager::~ApplicationManager()
 {
     qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::~ApplicationManager";
+    delete m_dbusFocusInfo;
 }
 
 int ApplicationManager::rowCount(const QModelIndex &parent) const
 
=== modified file 'miral-qt/src/modules/Unity/Application/application_manager.h'
--- miral-qt/src/modules/Unity/Application/application_manager.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/application_manager.h	2016-07-26 12:46:18 +0000
@@ -49,6 +49,7 @@
 
 namespace qtmir {
 
+class DBusFocusInfo;
 class DBusWindowStack;
 class MirSurfaceManager;
 class ProcInfo;
@@ -138,6 +139,7 @@
     Application *findApplication(MirSurfaceInterface* surface);
 
     QList<Application*> m_applications;
+    DBusFocusInfo *m_dbusFocusInfo;
     DBusWindowStack* m_dbusWindowStack;
     QSharedPointer<TaskController> m_taskController;
     QSharedPointer<ProcInfo> m_procInfo;
 
=== added file 'miral-qt/src/modules/Unity/Application/cgmanager.cpp'
--- miral-qt/src/modules/Unity/Application/cgmanager.cpp	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/cgmanager.cpp	2016-07-26 12:46:18 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cgmanager.h"
+
+// QPA mirserver
+#include <logging.h>
+
+#include <cgmanager/cgmanager.h>
+
+#include <QDBusArgument>
+#include <QDBusMessage>
+
+using namespace qtmir;
+
+// According to D-Bus interface defined in:
+// https://github.com/lxc/cgmanager/blob/master/org.linuxcontainers.cgmanager.xml
+
+CGManager::CGManager(QObject *parent)
+    : QObject(parent)
+{
+}
+
+CGManager::~CGManager()
+{
+    QDBusConnection::disconnectFromPeer("cgmanager");
+}
+
+QDBusConnection CGManager::getConnection()
+{
+    auto connection = QDBusConnection("cgmanager");
+
+    if (!connection.isConnected()) {
+        connection = QDBusConnection::connectToPeer(CGMANAGER_DBUS_PATH, "cgmanager");
+        if (!connection.isConnected()) {
+            qCWarning(QTMIR_DBUS, "CGManager: Failed to connect to %s", CGMANAGER_DBUS_PATH);
+        }
+    }
+
+    return connection;
+}
+
+QString CGManager::getCGroupOfPid(const QString &controller, pid_t pid)
+{
+    auto connection = getConnection();
+    if (!connection.isConnected()) {
+        return QString();
+    }
+
+    auto message = QDBusMessage::createMethodCall(QString() /*service*/, m_path, m_interface, "GetPidCgroup");
+
+    QList<QVariant> arguments;
+    arguments << QVariant(controller);
+    arguments << QVariant((int)pid);
+
+    message.setArguments(arguments);
+
+    QDBusMessage reply = connection.call(message);
+
+    if (reply.type() == QDBusMessage::ReplyMessage) {
+        return reply.arguments()[0].toString();
+    } else {
+        Q_ASSERT(reply.type() == QDBusMessage::ErrorMessage);
+        qCWarning(QTMIR_DBUS) << "CGManager::getCGroupOfPid failed." << reply.errorMessage();
+        return QString();
+    }
+}
+
+QSet<pid_t> CGManager::getTasks(const QString &controller, const QString &cgroup)
+{
+    auto connection = getConnection();
+    if (!connection.isConnected()) {
+        return QSet<pid_t>();
+    }
+
+    auto message = QDBusMessage::createMethodCall(QString() /*service*/, m_path, m_interface, "GetTasks");
+
+    QList<QVariant> arguments;
+    arguments << QVariant(controller);
+    arguments << QVariant(cgroup);
+
+    message.setArguments(arguments);
+
+    QDBusMessage reply = connection.call(message);
+
+    if (reply.type() == QDBusMessage::ErrorMessage) {
+        qCWarning(QTMIR_DBUS) << "CGManager::getCGroupOfPid failed." << reply.errorMessage();
+        return QSet<pid_t>();
+    }
+
+    Q_ASSERT(reply.type() == QDBusMessage::ReplyMessage);
+
+    auto arg = reply.arguments()[0].value<QDBusArgument>();
+    Q_ASSERT(arg.currentType() == QDBusArgument::ArrayType);
+
+    auto pidList = qdbus_cast<QList<int>>(arg);
+    Q_ASSERT(pidList.count() > 0);
+
+    QSet<pid_t> pidSet;
+    for (int i = 0; i < pidList.count(); ++i) {
+        pidSet << (pid_t)pidList[i];
+    }
+    return pidSet;
+}
 
=== added file 'miral-qt/src/modules/Unity/Application/cgmanager.h'
--- miral-qt/src/modules/Unity/Application/cgmanager.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/cgmanager.h	2016-07-26 12:46:18 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QTMIR_CGMANAGER_H
+#define QTMIR_CGMANAGER_H
+
+#include <QDBusConnection>
+
+namespace qtmir {
+
+class CGManager : public QObject {
+    Q_OBJECT
+public:
+    CGManager(QObject *parent = nullptr);
+    virtual ~CGManager();
+
+    QString getCGroupOfPid(const QString &controller, pid_t pid);
+
+    QSet<pid_t> getTasks(const QString &controller, const QString &cgroup);
+
+private:
+    const QString m_interface{"org.linuxcontainers.cgmanager0_0"};
+    const QString m_path{"/org/linuxcontainers/cgmanager"};
+    QDBusConnection getConnection();
+};
+
+} // namespace qtmir
+
+#endif // QTMIR_CGMANAGER_H
 
=== added file 'miral-qt/src/modules/Unity/Application/dbusfocusinfo.cpp'
--- miral-qt/src/modules/Unity/Application/dbusfocusinfo.cpp	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/dbusfocusinfo.cpp	2016-07-26 12:46:18 +0000
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dbusfocusinfo.h"
+
+// local
+#include "cgmanager.h"
+
+// QPA mirserver
+#include <logging.h>
+
+#include <QDBusConnection>
+
+using namespace qtmir;
+
+DBusFocusInfo::DBusFocusInfo(const QList<Application*> &applications)
+    : m_applications(applications)
+{
+    QDBusConnection::sessionBus().registerService("com.canonical.Unity.FocusInfo");
+    QDBusConnection::sessionBus().registerObject("/com/canonical/Unity/FocusInfo", this, QDBusConnection::ExportScriptableSlots);
+
+    m_cgManager = new CGManager(this);
+}
+
+bool DBusFocusInfo::isPidFocused(unsigned int pid)
+{
+    if (QCoreApplication::applicationPid() == (qint64)pid) {
+        // Shell itself.
+        // Don't bother checking if it has a QML with activeFocus() which is not a MirSurfaceItem.
+        return true;
+    } else {
+        auto pidSet = fetchAssociatedPids((pid_t)pid);
+        SessionInterface *session = findSessionWithPid(pidSet);
+        return session ? session->activeFocus() : false;
+    }
+}
+
+QSet<pid_t> DBusFocusInfo::fetchAssociatedPids(pid_t pid)
+{
+    QString cgroup = m_cgManager->getCGroupOfPid("freezer", pid);
+
+    // If a cgroup has a format like this:
+    // /user.slice/user-32011.slice/session-c3.scope/upstart/application-legacy-puritine_gedit_0.0-
+    // All PIds in it are associated with a single application.
+    if (cgroup.split("/").contains("upstart")) {
+        QSet<pid_t> pidSet = m_cgManager->getTasks("freezer", cgroup);
+        qCDebug(QTMIR_DBUS) << "DBusFocusInfo: pid" << pid << "is in cgroup" << cgroup << "along with:" << pidSet;
+        if (pidSet.isEmpty()) {
+            pidSet << pid;
+        }
+        return pidSet;
+    } else {
+        qCDebug(QTMIR_DBUS) << "DBusFocusInfo: pid" << pid << "is in cgroup" << cgroup << "which is not app-specific";
+        return QSet<pid_t>({pid});
+    }
+}
+
+SessionInterface* DBusFocusInfo::findSessionWithPid(const QSet<pid_t> &pidSet)
+{
+    Q_FOREACH (Application* application, m_applications) {
+        auto session = application->session();
+        if (pidSet.contains(session->pid())) {
+            return session;
+        }
+        SessionInterface *chosenChildSession = nullptr;
+        session->foreachChildSession([&](SessionInterface* childSession) {
+            if (pidSet.contains(childSession->pid())) {
+                chosenChildSession = childSession;
+            }
+        });
+        if (chosenChildSession) {
+            return chosenChildSession;
+        }
+    }
+    return nullptr;
+}
 
=== added file 'miral-qt/src/modules/Unity/Application/dbusfocusinfo.h'
--- miral-qt/src/modules/Unity/Application/dbusfocusinfo.h	1970-01-01 00:00:00 +0000
+++ miral-qt/src/modules/Unity/Application/dbusfocusinfo.h	2016-07-26 12:46:18 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QList>
+#include <QSet>
+
+#include "application.h"
+
+namespace qtmir {
+
+class CGManager;
+
+/*
+  FIXME: This is a hack to provide OSK with needed info for avoiding input snooping.
+         Remove when possible
+ */
+class DBusFocusInfo : public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.FocusInfo")
+public:
+    explicit DBusFocusInfo(const QList<Application*> &applications);
+    virtual ~DBusFocusInfo() {}
+
+public Q_SLOTS:
+
+    /*
+        Returns true if the application with the given PID has input focus
+     */
+    Q_SCRIPTABLE bool isPidFocused(unsigned int pid);
+
+private:
+    QSet<pid_t> fetchAssociatedPids(pid_t pid);
+    SessionInterface* findSessionWithPid(const QSet<pid_t> &pidSet);
+
+    const QList<Application*> &m_applications;
+
+    CGManager *m_cgManager;
+};
+
+} // namespace qtmir
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-07-25 13:48:41 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.cpp	2016-07-26 12:46:18 +0000
@@ -219,6 +219,7 @@
         connect(observer.get(), &SurfaceObserver::shellChromeChanged, this, [&](MirShellChrome shell_chrome) {
             setShellChrome(static_cast<Mir::ShellChrome>(shell_chrome));
         });
+        connect(observer.get(), &SurfaceObserver::inputBoundsChanged, this, &MirSurface::setInputBounds);
         observer->setListener(this);
     }
 
@@ -277,12 +278,15 @@
 {
     switch (attribute) {
     case mir_surface_attrib_type:
+        DEBUG_MSG << " type = " << mirSurfaceTypeToStr(state());
         Q_EMIT typeChanged(type());
         break;
     case mir_surface_attrib_state:
+        DEBUG_MSG << " state = " << mirSurfaceStateToStr(state());
         Q_EMIT stateChanged(state());
         break;
     case mir_surface_attrib_visibility:
+        DEBUG_MSG << " visible = " << visible();
         Q_EMIT visibleChanged(visible());
         break;
     default:
@@ -453,6 +457,11 @@
     }
 }
 
+bool MirSurface::activeFocus() const
+{
+    return !m_activelyFocusedViews.empty();
+}
+
 void MirSurface::updateActiveFocus()
 {
     if (!m_session) {
@@ -871,6 +880,24 @@
     }
 }
 
+bool MirSurface::inputAreaContains(const QPoint &point) const
+{
+    bool result;
+
+
+    // Can't use it due to https://bugs.launchpad.net/mir/+bug/1598936
+    // FIXME: Use the line below instead of m_inputBounds once this bug gets fixed.
+    //result = m_surface->input_area_contains(mir::geometry::Point(point.x(), point.y()));
+
+    if (m_inputBounds.isNull()) {
+        result = true;
+    } else {
+        result = m_inputBounds.contains(point);
+    }
+
+    return result;
+}
+
 void MirSurface::setCursor(const QCursor &cursor)
 {
     DEBUG_MSG << "(" << qtCursorShapeToStr(cursor.shape()) << ")";
@@ -962,6 +989,11 @@
     return m_focused;
 }
 
+QRect MirSurface::inputBounds() const
+{
+    return m_inputBounds;
+}
+
 void MirSurface::requestFocus()
 {
     DEBUG_MSG << "()";
@@ -1003,3 +1035,12 @@
         m_closeTimer->start();
     }
 }
+
+void MirSurface::setInputBounds(const QRect &rect)
+{
+    if (m_inputBounds != rect) {
+        DEBUG_MSG << "(" << rect << ")";
+        m_inputBounds = rect;
+        Q_EMIT inputBoundsChanged(m_inputBounds);
+    }
+}
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurface.h'
--- miral-qt/src/modules/Unity/Application/mirsurface.h	2016-07-25 13:48:41 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurface.h	2016-07-26 12:46:18 +0000
@@ -24,6 +24,7 @@
 #include <QCursor>
 #include <QMutex>
 #include <QPointer>
+#include <QRect>
 #include <QSharedPointer>
 #include <QWeakPointer>
 #include <QSet>
@@ -89,6 +90,7 @@
     int heightIncrement() const override;
 
     bool focused() const override;
+    QRect inputBounds() const override;
 
     Q_INVOKABLE void requestFocus() override;
     Q_INVOKABLE void close() override;
@@ -121,6 +123,7 @@
     void setFocused(bool focus) override;
 
     void setViewActiveFocus(qintptr viewId, bool value) override;
+    bool activeFocus() const override;
 
     void mousePressEvent(QMouseEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
@@ -149,6 +152,8 @@
 
     SessionInterface* session() override { return m_session.data(); }
 
+    bool inputAreaContains(const QPoint &) const override;
+
     ////
     // Own API
 
@@ -174,6 +179,7 @@
     void emitSizeChanged();
     void setCursor(const QCursor &cursor);
     void onCloseTimedOut();
+    void setInputBounds(const QRect &rect);
 
 private:
     void syncSurfaceSizeWithItemSize();
@@ -223,6 +229,8 @@
     int m_widthIncrement{0};
     int m_heightIncrement{0};
 
+    QRect m_inputBounds;
+
     bool m_focused{false};
 
     enum ClosingState {
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h'
--- miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-25 13:48:41 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-26 12:46:18 +0000
@@ -77,6 +77,10 @@
         the name.
      */
     virtual void setViewActiveFocus(qintptr viewId, bool value) = 0;
+    /*
+        Whether any view of this surface currently has QML active focus
+     */
+    virtual bool activeFocus() const = 0;
 
     virtual void mousePressEvent(QMouseEvent *event) = 0;
     virtual void mouseMoveEvent(QMouseEvent *event) = 0;
@@ -100,6 +104,8 @@
 
     virtual SessionInterface* session() = 0;
 
+    virtual bool inputAreaContains(const QPoint &) const = 0;
+
 public Q_SLOTS:
     virtual void onCompositorSwappedBuffers() = 0;
 
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceitem.cpp'
--- miral-qt/src/modules/Unity/Application/mirsurfaceitem.cpp	2016-07-25 13:48:41 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceitem.cpp	2016-07-26 12:46:18 +0000
@@ -20,7 +20,6 @@
 #include "mirsurfaceitem.h"
 #include "mirfocuscontroller.h"
 #include "logging.h"
-#include "ubuntukeyboardinfo.h"
 #include "tracepoints.h" // generated from tracepoints.tp
 #include "timestamp.h"
 
@@ -103,10 +102,6 @@
     setSmooth(true);
     setFlag(QQuickItem::ItemHasContents, true); //so scene graph will render this item
 
-    if (!UbuntuKeyboardInfo::instance()) {
-        new UbuntuKeyboardInfo;
-    }
-
     m_updateMirSurfaceSizeTimer.setSingleShot(true);
     m_updateMirSurfaceSizeTimer.setInterval(1);
     connect(&m_updateMirSurfaceSizeTimer, &QTimer::timeout, this, &MirSurfaceItem::updateMirSurfaceSize);
@@ -290,17 +285,9 @@
 
 void MirSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
-    if (m_consumesInput && m_surface && m_surface->live()) {
-        if (type() == Mir::InputMethodType) {
-            // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
-            if (isMouseInsideUbuntuKeyboard(event)) {
-                m_surface->mousePressEvent(event);
-            } else {
-                event->ignore();
-            }
-        } else {
-            m_surface->mousePressEvent(event);
-        }
+    auto mousePos = event->localPos().toPoint();
+    if (m_consumesInput && m_surface && m_surface->live() && m_surface->inputAreaContains(mousePos)) {
+        m_surface->mousePressEvent(event);
     } else {
         event->ignore();
     }
@@ -471,51 +458,26 @@
         return false;
     }
 
-    bool accepted = true;
-    if (type() == Mir::InputMethodType && eventType == QEvent::TouchBegin) {
-        // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
-        if (hasTouchInsideUbuntuKeyboard(touchPoints)) {
-            validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
-        } else {
-            accepted = false;
-        }
-
-    } else {
-        // NB: If we are getting QEvent::TouchUpdate or QEvent::TouchEnd it's because we've
-        // previously accepted the corresponding QEvent::TouchBegin
-        validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
+    if (eventType == QEvent::TouchBegin && !hasTouchInsideInputRegion(touchPoints)) {
+        return false;
     }
-    return accepted;
+
+    validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
+
+    return true;
 }
 
-bool MirSurfaceItem::hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints)
+bool MirSurfaceItem::hasTouchInsideInputRegion(const QList<QTouchEvent::TouchPoint> &touchPoints)
 {
-    UbuntuKeyboardInfo *ubuntuKeyboardInfo = UbuntuKeyboardInfo::instance();
-
     for (int i = 0; i < touchPoints.count(); ++i) {
         QPoint pos = touchPoints.at(i).pos().toPoint();
-        if (pos.x() >= ubuntuKeyboardInfo->x()
-                && pos.x() <= (ubuntuKeyboardInfo->x() + ubuntuKeyboardInfo->width())
-                && pos.y() >= ubuntuKeyboardInfo->y()
-                && pos.y() <= (ubuntuKeyboardInfo->y() + ubuntuKeyboardInfo->height())) {
+        if (m_surface->inputAreaContains(pos)) {
             return true;
         }
     }
     return false;
 }
 
-bool MirSurfaceItem::isMouseInsideUbuntuKeyboard(const QMouseEvent *event)
-{
-    UbuntuKeyboardInfo *ubuntuKeyboardInfo = UbuntuKeyboardInfo::instance();
-
-    const QPointF &pos = event->localPos();
-
-    return pos.x() >= ubuntuKeyboardInfo->x()
-        && pos.x() <= (ubuntuKeyboardInfo->x() + ubuntuKeyboardInfo->width())
-        && pos.y() >= ubuntuKeyboardInfo->y()
-        && pos.y() <= (ubuntuKeyboardInfo->y() + ubuntuKeyboardInfo->height());
-}
-
 Mir::State MirSurfaceItem::surfaceState() const
 {
     if (m_surface) {
 
=== modified file 'miral-qt/src/modules/Unity/Application/mirsurfaceitem.h'
--- miral-qt/src/modules/Unity/Application/mirsurfaceitem.h	2016-07-25 13:48:41 +0000
+++ miral-qt/src/modules/Unity/Application/mirsurfaceitem.h	2016-07-26 12:46:18 +0000
@@ -126,8 +126,7 @@
 private:
     void ensureTextureProvider();
 
-    bool hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints);
-    bool isMouseInsideUbuntuKeyboard(const QMouseEvent *event);
+    bool hasTouchInsideInputRegion(const QList<QTouchEvent::TouchPoint> &touchPoints);
 
     QString appId() const;
     void endCurrentTouchSequence(ulong timestamp);
 
=== modified file 'miral-qt/src/modules/Unity/Application/plugin.cpp'
--- miral-qt/src/modules/Unity/Application/plugin.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/plugin.cpp	2016-07-26 12:46:18 +0000
@@ -25,7 +25,6 @@
 #include "mirsurfaceinterface.h"
 #include "mirsurfaceitem.h"
 #include "mirsurfacelistmodel.h"
-#include "ubuntukeyboardinfo.h"
 
 // platforms/mirserver
 #include <mirsingleton.h>
@@ -55,13 +54,6 @@
     return qtmir::MirSurfaceManager::singleton();
 }
 
-QObject* ubuntuKeyboardInfoSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
-    if (!UbuntuKeyboardInfo::instance()) {
-        new UbuntuKeyboardInfo;
-    }
-    return UbuntuKeyboardInfo::instance();
-}
-
 QObject* mirSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
     return qtmir::Mir::instance();
 }
@@ -101,8 +93,6 @@
         qmlRegisterUncreatableType<unity::shell::application::MirSurfaceInterface>(
                     uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");
         qmlRegisterType<qtmir::MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");
-        qmlRegisterSingletonType<qtmir::UbuntuKeyboardInfo>(
-                uri, 0, 1, "UbuntuKeyboardInfo", ubuntuKeyboardInfoSingleton);
         qmlRegisterSingletonType<qtmir::Mir>(uri, 0, 1, "Mir", mirSingleton);
     }
 
 
=== modified file 'miral-qt/src/modules/Unity/Application/session.cpp'
--- miral-qt/src/modules/Unity/Application/session.cpp	2016-06-21 13:38:53 +0000
+++ miral-qt/src/modules/Unity/Application/session.cpp	2016-07-26 12:46:18 +0000
@@ -514,6 +514,23 @@
     return m_hadSurface;
 }
 
+bool Session::activeFocus() const
+{
+    for (int i = 0; i < m_surfaceList.count(); ++i) {
+        auto surface = static_cast<const MirSurfaceInterface*>(m_surfaceList.get(i));
+        if (surface->activeFocus()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+pid_t Session::pid() const
+{
+    return m_session->process_id();
+}
+
 void Session::setSuspendTimer(AbstractTimer *timer)
 {
     bool timerWasRunning = false;
 
=== modified file 'miral-qt/src/modules/Unity/Application/session.h'
--- miral-qt/src/modules/Unity/Application/session.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/session.h	2016-07-26 12:46:18 +0000
@@ -67,6 +67,10 @@
     bool hadSurface() const override;
     bool hasClosingSurfaces() const override;
 
+    bool activeFocus() const override;
+
+    pid_t pid() const override;
+
     void addChildSession(SessionInterface* session) override;
     void insertChildSession(uint index, SessionInterface* session) override;
     void removeChildSession(SessionInterface* session) override;
 
=== modified file 'miral-qt/src/modules/Unity/Application/session_interface.h'
--- miral-qt/src/modules/Unity/Application/session_interface.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/session_interface.h	2016-07-26 12:46:18 +0000
@@ -92,6 +92,12 @@
     virtual bool hadSurface() const = 0; // whether this session ever had any surface (currently or in the past)
     virtual bool hasClosingSurfaces() const = 0; // whether it has surfaces being forcibly closed
 
+    // Whether any of its MirSurfaces has activeFocus()
+    // See qtmir::MirSurfaceInterface::activeFocus
+    virtual bool activeFocus() const = 0;
+
+    virtual pid_t pid() const = 0;
+
     // For SessionManager use
 
     virtual void addChildSession(SessionInterface* session) = 0;
 
=== removed file 'miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.cpp'
--- miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.cpp	2016-06-21 13:38:53 +0000
+++ miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.cpp	1970-01-01 00:00:00 +0000
@@ -1,173 +0,0 @@
-/*
- * Copyright (C) 2013-2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "ubuntukeyboardinfo.h"
-
-#include <QDir>
-
-namespace qtmir {
-
-namespace {
-    const int gConnectionAttemptIntervalMs = 5000;
-    const int gMaxConsecutiveAttempts = 10;
-    const char gServerName[] = "ubuntu-keyboard-info";
-}
-
-UbuntuKeyboardInfo* UbuntuKeyboardInfo::m_instance = nullptr;
-
-UbuntuKeyboardInfo* UbuntuKeyboardInfo::instance()
-{
-    return m_instance;
-}
-
-UbuntuKeyboardInfo::UbuntuKeyboardInfo(QObject *parent)
-    : QObject(parent),
-    m_consecutiveAttempts(0),
-    m_lastX(0),
-    m_lastY(0),
-    m_lastWidth(0),
-    m_lastHeight(0)
-{
-    if (m_instance) {
-        qFatal("Cannot have more than one instance of UbuntuKeyboardInfo simultaneously.");
-    }
-    m_instance = this;
-
-    connect(&m_socket, &QLocalSocket::stateChanged, this, &UbuntuKeyboardInfo::onSocketStateChanged);
-    connect(&m_socket, &QIODevice::readyRead,
-            this, &UbuntuKeyboardInfo::readAllBytesFromSocket);
-
-    buildSocketFilePath();
-
-    typedef void (QLocalSocket::*MemberFunctionType)(QLocalSocket::LocalSocketError);
-    MemberFunctionType funcPointer = &QLocalSocket::error;
-    connect(&m_socket, funcPointer,
-            this, &UbuntuKeyboardInfo::onSocketError);
-
-    m_connectionRetryTimer.setInterval(gConnectionAttemptIntervalMs);
-    m_connectionRetryTimer.setSingleShot(true);
-    connect(&m_connectionRetryTimer, &QTimer::timeout,
-            this, &UbuntuKeyboardInfo::tryConnectingToServer);
-    tryConnectingToServer();
-}
-
-UbuntuKeyboardInfo::~UbuntuKeyboardInfo()
-{
-    // Make sure we don't get onSocketStateChanged() called during
-    // destruction.
-    m_socket.disconnect(this);
-
-    Q_ASSERT(m_instance);
-    m_instance = nullptr;
-}
-
-void UbuntuKeyboardInfo::tryConnectingToServer()
-{
-    ++m_consecutiveAttempts;
-    Q_ASSERT(!m_socketFilePath.isEmpty());
-    m_socket.connectToServer(m_socketFilePath, QIODevice::ReadOnly);
-}
-
-void UbuntuKeyboardInfo::onSocketStateChanged(QLocalSocket::LocalSocketState socketState)
-{
-    switch (socketState) {
-    case QLocalSocket::UnconnectedState:
-        retryConnection();
-        break;
-    case QLocalSocket::ConnectedState:
-        m_consecutiveAttempts = 0;
-        break;
-    default:
-        break;
-    }
-}
-
-void UbuntuKeyboardInfo::onSocketError(QLocalSocket::LocalSocketError socketError)
-{
-    Q_UNUSED(socketError);
-    qWarning() << "UbuntuKeyboardInfo - socket error:" << m_socket.errorString();
-}
-
-void UbuntuKeyboardInfo::retryConnection()
-{
-    // Polling every gConnectionAttemptIntervalMs. Not the best approach but could be worse.
-    if (m_consecutiveAttempts < gMaxConsecutiveAttempts) {
-        if (!m_connectionRetryTimer.isActive()) {
-            m_connectionRetryTimer.start();
-        }
-    } else {
-        qCritical() << "Failed to connect to" << m_socketFilePath << "after"
-                    << m_consecutiveAttempts << "failed attempts";
-
-        // it shouldn't be running, but just to be sure.
-        m_connectionRetryTimer.stop();
-    }
-}
-
-void UbuntuKeyboardInfo::readAllBytesFromSocket()
-{
-    while (m_socket.bytesAvailable() > 0) {
-        readInfoFromSocket();
-    }
-}
-
-void UbuntuKeyboardInfo::readInfoFromSocket()
-{
-    const size_t sharedInfoSize = sizeof(struct SharedInfo);
-    QByteArray bytes = m_socket.read(sharedInfoSize);
-    if (bytes.size() != sharedInfoSize) {
-        qWarning() << "UbuntuKeyboardInfo: expected to receive" << sharedInfoSize
-                   << "but got" << bytes.size();
-        return;
-    }
-
-    {
-        struct SharedInfo *sharedInfo = reinterpret_cast<struct SharedInfo*>(bytes.data());
-
-        if (m_lastX != sharedInfo->keyboardX) {
-            m_lastX = sharedInfo->keyboardX;
-            Q_EMIT xChanged(m_lastX);
-        }
-
-        if (m_lastY != sharedInfo->keyboardY) {
-            m_lastY = sharedInfo->keyboardY;
-            Q_EMIT yChanged(m_lastY);
-        }
-
-        if (m_lastWidth != sharedInfo->keyboardWidth) {
-            m_lastWidth = sharedInfo->keyboardWidth;
-            Q_EMIT widthChanged(m_lastWidth);
-        }
-
-        if (m_lastHeight != sharedInfo->keyboardHeight) {
-            m_lastHeight = sharedInfo->keyboardHeight;
-            Q_EMIT heightChanged(m_lastHeight);
-        }
-    }
-}
-
-void UbuntuKeyboardInfo::buildSocketFilePath()
-{
-    char *xdgRuntimeDir = getenv("XDG_RUNTIME_DIR");
-
-    if (xdgRuntimeDir) {
-        m_socketFilePath = QDir(xdgRuntimeDir).filePath(gServerName);
-    } else {
-        m_socketFilePath = QDir("/tmp").filePath(gServerName);
-    }
-}
-
-} // namespace qtmir
 
=== removed file 'miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.h'
--- miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/modules/Unity/Application/ubuntukeyboardinfo.h	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2013-2015 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef UBUNTU_KEYBOARD_INFO_H
-#define UBUNTU_KEYBOARD_INFO_H
-
-#include <QLocalSocket>
-#include <QTimer>
-
-namespace qtmir {
-
-// Temporary solution to get information about the onscreen keyboard
-// This shouldn't be needed once the OSK is a properly sized surface
-// instead of a fullscreen one.
-class UbuntuKeyboardInfo : public QObject {
-    Q_OBJECT
-    Q_PROPERTY(qreal x READ x NOTIFY xChanged)
-    Q_PROPERTY(qreal y READ y NOTIFY yChanged)
-    Q_PROPERTY(qreal width READ width NOTIFY widthChanged)
-    Q_PROPERTY(qreal height READ height NOTIFY heightChanged)
-public:
-    UbuntuKeyboardInfo(QObject *parent = 0);
-    virtual ~UbuntuKeyboardInfo();
-
-    static UbuntuKeyboardInfo* instance();
-
-    qreal x() const { return m_lastX; }
-    qreal y() const { return m_lastY; }
-    qreal width() const { return m_lastWidth; }
-    qreal height() const { return m_lastHeight; }
-
-Q_SIGNALS:
-    void xChanged(qreal x);
-    void yChanged(qreal y);
-    void widthChanged(qreal width);
-    void heightChanged(qreal height);
-
-private Q_SLOTS:
-    void tryConnectingToServer();
-    void onSocketStateChanged(QLocalSocket::LocalSocketState socketState);
-    void onSocketError(QLocalSocket::LocalSocketError socketError);
-    void readAllBytesFromSocket();
-
-private:
-    // NB! Must match the definition in ubuntu-keyboard. Not worth creating a shared header
-    // just for that.
-    struct SharedInfo {
-        qint32 keyboardX;
-        qint32 keyboardY;
-        qint32 keyboardWidth;
-        qint32 keyboardHeight;
-    };
-    void readInfoFromSocket();
-    void retryConnection();
-    void buildSocketFilePath();
-
-    int m_consecutiveAttempts;
-
-    QLocalSocket m_socket;
-    qint32 m_lastX;
-    qint32 m_lastY;
-    qint32 m_lastWidth;
-    qint32 m_lastHeight;
-    QTimer m_connectionRetryTimer;
-
-    // Path to the socket file created by ubuntu-keyboard
-    QString m_socketFilePath;
-
-    static UbuntuKeyboardInfo* m_instance;
-};
-
-} // namespace qtmir
-
-#endif // UBUNTU_KEYBOARD_INFO_H
 
=== modified file 'miral-qt/src/platforms/mirserver/logging.cpp'
--- miral-qt/src/platforms/mirserver/logging.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/logging.cpp	2016-07-26 12:46:18 +0000
@@ -24,3 +24,4 @@
 Q_LOGGING_CATEGORY(QTMIR_CLIPBOARD, "qtmir.clipboard")
 Q_LOGGING_CATEGORY(QTMIR_SENSOR_MESSAGES, "qtmir.sensor")
 Q_LOGGING_CATEGORY(QTMIR_SCREENS, "qtmir.screens")
+Q_LOGGING_CATEGORY(QTMIR_DBUS, "qtmir.dbus", QtWarningMsg)
 
=== modified file 'miral-qt/src/platforms/mirserver/logging.h'
--- miral-qt/src/platforms/mirserver/logging.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/logging.h	2016-07-26 12:46:18 +0000
@@ -26,5 +26,6 @@
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_INPUT)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_CLIPBOARD)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SCREENS)
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_DBUS)
 
 #endif // UBUNTU_APPLICATION_PLUGIN_LOGGING_H
 
=== modified file 'miral-qt/src/platforms/mirserver/mirwindowmanager.cpp'
--- miral-qt/src/platforms/mirserver/mirwindowmanager.cpp	2016-06-07 18:03:38 +0000
+++ miral-qt/src/platforms/mirserver/mirwindowmanager.cpp	2016-07-26 12:46:18 +0000
@@ -197,14 +197,19 @@
                                           const mir::shell::SurfaceSpecification& modifications)
 {
     QMutexLocker lock(&SurfaceObserver::mutex);
+
+    if (modifications.name.is_set()) {
+        surface->rename(modifications.name.value());
+    }
+
+    if (modifications.input_shape.is_set()) {
+        surface->set_input_region(modifications.input_shape.value());
+    }
+
     SurfaceObserver *observer = SurfaceObserver::observerForSurface(surface.get());
     if (observer) {
         observer->notifySurfaceModifications(modifications);
     }
-
-    if (modifications.name.is_set()) {
-        surface->rename(modifications.name.value());
-    }
 }
 
 std::shared_ptr<MirWindowManager> MirWindowManager::create(
 
=== modified file 'miral-qt/src/platforms/mirserver/surfaceobserver.cpp'
--- miral-qt/src/platforms/mirserver/surfaceobserver.cpp	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/surfaceobserver.cpp	2016-07-26 12:46:18 +0000
@@ -28,6 +28,22 @@
 #include <mir/geometry/size.h>
 #include <mir/shell/surface_specification.h>
 
+namespace {
+
+QRect calculateBoundingRect(const std::vector<mir::geometry::Rectangle> &rectVector)
+{
+    QRect boundingRect;
+    for (auto mirRect : rectVector) {
+        boundingRect |= QRect(mirRect.top_left.x.as_int(),
+                mirRect.top_left.y.as_int(),
+                mirRect.size.width.as_int(),
+                mirRect.size.height.as_int());
+    }
+    return boundingRect;
+}
+
+} // anonymous namespace
+
 QMap<const mir::scene::Surface*, SurfaceObserver*> SurfaceObserver::m_surfaceToObserverMap;
 QMutex SurfaceObserver::mutex;
 
@@ -154,6 +170,10 @@
     if (modifications.shell_chrome.is_set()) {
         Q_EMIT shellChromeChanged(modifications.shell_chrome.value());
     }
+    if (modifications.input_shape.is_set()) {
+        QRect qRect = calculateBoundingRect(modifications.input_shape.value());
+        Q_EMIT inputBoundsChanged(qRect);
+    }
 }
 
 SurfaceObserver *SurfaceObserver::observerForSurface(const mir::scene::Surface *surface)
 
=== modified file 'miral-qt/src/platforms/mirserver/surfaceobserver.h'
--- miral-qt/src/platforms/mirserver/surfaceobserver.h	2016-06-01 22:06:51 +0000
+++ miral-qt/src/platforms/mirserver/surfaceobserver.h	2016-07-26 12:46:18 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Canonical, Ltd.
+ * Copyright (C) 2014-2016 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License version 3, as published by
@@ -22,6 +22,7 @@
 #include <QObject>
 #include <QMap>
 #include <QMutex>
+#include <QRect>
 #include <QSize>
 #include <mir/scene/surface_observer.h>
 
@@ -84,6 +85,7 @@
     void widthIncrementChanged(int);
     void heightIncrementChanged(int);
     void shellChromeChanged(MirShellChrome);
+    void inputBoundsChanged(const QRect &rect);
 
 private:
     QCursor createQCursorFromMirCursorImage(const mir::graphics::CursorImage &cursorImage);
 
=== modified file 'miral-qt/tests/framework/fake_mirsurface.h'
--- miral-qt/tests/framework/fake_mirsurface.h	2016-07-25 13:48:41 +0000
+++ miral-qt/tests/framework/fake_mirsurface.h	2016-07-26 12:46:18 +0000
@@ -76,6 +76,7 @@
     Mir::ShellChrome shellChrome() const override { return Mir::NormalChrome; }
 
     bool focused() const override { return false; }
+    QRect inputBounds() const override { return QRect(0,0,10,10); }
 
     void requestFocus() override {
         Q_EMIT focusRequested();
@@ -110,6 +111,7 @@
     void setFocused(bool focus) override;
 
     void setViewActiveFocus(qintptr, bool) override {};
+    bool activeFocus() const override { return false; }
 
     void mousePressEvent(QMouseEvent *) override;
     void mouseMoveEvent(QMouseEvent *) override;
@@ -132,6 +134,8 @@
 
     SessionInterface* session() override { return m_session; }
 
+    bool inputAreaContains(const QPoint &) const override { return true; }
+
 public Q_SLOTS:
     void onCompositorSwappedBuffers() override;
 
 
=== modified file 'miral-qt/tests/framework/fake_session.h'
--- miral-qt/tests/framework/fake_session.h	2016-06-07 20:32:04 +0000
+++ miral-qt/tests/framework/fake_session.h	2016-07-26 12:46:18 +0000
@@ -58,6 +58,10 @@
 
     void close() override;
 
+    bool activeFocus() const override { return false; }
+
+    pid_t pid() const override { return 0; }
+
     // For SessionManager use
 
     void addChildSession(SessionInterface*) override;