Merge lp:~gerboland/unity-mir/surface-notifications into lp:unity-mir

[Gerry Boland]

Update SurfaceManager and ApplicationManager to make use of new MIR API, which notifies of surface creation and destruction per session/application.

Update SurfaceManager and ApplicationManager to make use of new MIR API, which notifies of surface creation and destruction per session/application.

[lp:~gerboland/unity-mir/surface-notifications]

22. By Gerry Boland on 2013-07-24

Unset mainStageFocusedApplication if it is closed

23. By Gerry Boland on 2013-07-24

Merge trunk

24. By Gerry Boland on 2013-07-24

Reset mainStageFocusedApplication in stopProcess, fix crash on app close

25. By Gerry Boland on 2013-07-24

SurfaceManager: unable to keep msh::Surface as long as we want, so simplify API for now

[Albert Astals Cid (aacid)]

Looks good

review: Approve

=== modified file 'src/modules/Unity/ApplicationManager/application_list_model.cpp'
--- src/modules/Unity/ApplicationManager/application_list_model.cpp	2013-07-24 15:07:38 +0000
+++ src/modules/Unity/ApplicationManager/application_list_model.cpp	2013-07-24 17:24:27 +0000
@@ -19,6 +19,8 @@
 
 #include <mir/shell/application_session.h>
 
+namespace msh = mir::shell;
+
 ApplicationListModel::ApplicationListModel(QObject* parent)
 :   QAbstractListModel(parent)
 ,   m_applications()
@@ -100,11 +102,16 @@
     }
 }
 
-Application* ApplicationListModel::getApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session)
+Application* ApplicationListModel::getApplicationWithSession(const std::shared_ptr<msh::Session> &session)
+{
+    return getApplicationWithSession(session.get());
+}
+
+Application* ApplicationListModel::getApplicationWithSession(const msh::Session *session)
 {
     Application* app = NULL;
     Q_FOREACH(app, m_applications) {
-        if (app->session().get() == session.get()) {
+        if (app->session().get() == session) {
             break;
         }
     }
 
=== modified file 'src/modules/Unity/ApplicationManager/application_list_model.h'
--- src/modules/Unity/ApplicationManager/application_list_model.h	2013-07-24 15:07:38 +0000
+++ src/modules/Unity/ApplicationManager/application_list_model.h	2013-07-24 17:24:27 +0000
@@ -49,6 +49,7 @@
     void remove(Application* application);
 
     Application* getApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session);
+    Application* getApplicationWithSession(const mir::shell::Session *session);
     Application* getApplicationWithId(const int id);
     Application* getApplicationWithPid(const int pid);
     Application* getLastExecutedApplication();
 
=== modified file 'src/modules/Unity/ApplicationManager/application_manager.cpp'
--- src/modules/Unity/ApplicationManager/application_manager.cpp	2013-07-24 15:44:10 +0000
+++ src/modules/Unity/ApplicationManager/application_manager.cpp	2013-07-24 17:24:27 +0000
@@ -25,6 +25,8 @@
   #include <pwd.h>
 #endif
 
+namespace msh = mir::shell;
+
 ApplicationManager::ApplicationManager(QObject *parent)
 :   QObject(parent)
 ,   m_mainStageApplications(new ApplicationListModel())
@@ -39,17 +41,16 @@
     }
     m_mirServer = mirServerApplication->server();
 
-    std::shared_ptr<SessionListener> sessionListener
-            = std::dynamic_pointer_cast<SessionListener>(m_mirServer->the_shell_session_listener());
-
-    QObject::connect(sessionListener.get(), &SessionListener::sessionStarting,
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionStarting,
                      this, &ApplicationManager::sessionStarting);
-    QObject::connect(sessionListener.get(), &SessionListener::sessionStopping,
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionStopping,
                      this, &ApplicationManager::sessionStopping);
-    QObject::connect(sessionListener.get(), &SessionListener::sessionFocused,
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionFocused,
                      this, &ApplicationManager::sessionFocused);
-    QObject::connect(sessionListener.get(), &SessionListener::sessionUnfocused,
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionUnfocused,
                      this, &ApplicationManager::sessionUnfocused);
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionCreatedSurface,
+                     this, &ApplicationManager::sessionCreatedSurface);
 
     std::shared_ptr<SessionAuthorizer> sessionAuthorizer
             = std::dynamic_pointer_cast<SessionAuthorizer>(m_mirServer->the_session_authorizer());
@@ -193,7 +194,13 @@
     DLOG("ApplicationManager::stopProcess (this=%p, application=%p)", this, application);
 
     if (application != NULL) {
+        if (application == m_mainStageFocusedApplication) {
+            // TODO(greyback) What to do?? Focus next app, or unfocus everything??
+            m_mainStageFocusedApplication = NULL;
+            Q_EMIT mainStageFocusedApplicationChanged();
+        }
         m_mainStageApplications->remove(application);
+        m_dbusWindowStack->WindowDestroyed(0, application->name());
 
         // Start process.
         bool result;
@@ -225,7 +232,7 @@
     }
 }
 
-void ApplicationManager::sessionStarting(std::shared_ptr<mir::shell::ApplicationSession> const& session)
+void ApplicationManager::sessionStarting(std::shared_ptr<msh::ApplicationSession> const& session)
 {
     DLOG("ApplicationManager::sessionStarting (this=%p, application=%s)", this, session->name().c_str());
 
@@ -234,15 +241,12 @@
     Application* application = m_mainStageApplications->getLastExecutedApplication();
     if (application && application->state() != Application::Running) {
         application->setSession(session);
-        application->setState(Application::Running);
-
-        m_dbusWindowStack->WindowCreated(0, application->name());
     } else {
         DLOG("ApplicationManager::sessionStarting - unauthorized application!!");
     }
 }
 
-void ApplicationManager::sessionStopping(std::shared_ptr<mir::shell::ApplicationSession> const& session)
+void ApplicationManager::sessionStopping(std::shared_ptr<msh::ApplicationSession> const& session)
 {
     DLOG("ApplicationManager::sessionStopping (this=%p, application=%s)", this, session->name().c_str());
 
@@ -250,14 +254,16 @@
     Application* application = m_mainStageApplications->getApplicationWithSession(session);
     if (application) {
         if (application == m_mainStageFocusedApplication) {
-            // TODO(greyback) either focus next app, or unfocus everything
+            // TODO(greyback) What to do?? Focus next app, or unfocus everything??
+            m_mainStageFocusedApplication = NULL;
+            Q_EMIT mainStageFocusedApplicationChanged();
         }
         m_mainStageApplications->remove(application);
         m_dbusWindowStack->WindowDestroyed(0, application->name());
     }
 }
 
-void ApplicationManager::sessionFocused(std::shared_ptr<mir::shell::ApplicationSession> const& session)
+void ApplicationManager::sessionFocused(std::shared_ptr<msh::ApplicationSession> const& session)
 {
     DLOG("ApplicationManager::sessionFocused (this=%p, application=%s)", this, session->name().c_str());
     Application* application = m_mainStageApplications->getApplicationWithSession(session);
@@ -280,3 +286,16 @@
     }
 }
 
+void ApplicationManager::sessionCreatedSurface(msh::ApplicationSession const* session,
+                                               std::shared_ptr<msh::Surface> const& surface)
+{
+    DLOG("ApplicationManager::sessionCreatedSurface (this=%p)", this);
+    Q_UNUSED(surface);
+
+    Application* application = m_mainStageApplications->getApplicationWithSession(session);
+    if (application && application->state() == Application::Starting) {
+        application->setState(Application::Running);
+
+        m_dbusWindowStack->WindowCreated(0, application->name());
+    }
+}
 
=== modified file 'src/modules/Unity/ApplicationManager/application_manager.h'
--- src/modules/Unity/ApplicationManager/application_manager.h	2013-07-24 15:07:38 +0000
+++ src/modules/Unity/ApplicationManager/application_manager.h	2013-07-24 17:24:27 +0000
@@ -14,7 +14,12 @@
 class ShellServerConfiguration;
 class DBusWindowStack;
 
-namespace mir { namespace shell { class ApplicationSession; }}
+namespace mir {
+    namespace shell {
+        class ApplicationSession;
+        class Surface;
+    }
+}
 
 class ApplicationManager : public QObject
 {
@@ -77,6 +82,8 @@
     void sessionFocused(std::shared_ptr<mir::shell::ApplicationSession> const& session);
     void sessionUnfocused();
 
+    void sessionCreatedSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const&);
+
 private:
     ApplicationListModel* m_mainStageApplications;
     Application* m_mainStageFocusedApplication; // remove as Mir has API for this
 
=== modified file 'src/modules/Unity/SurfaceManager/mirsurface.cpp'
--- src/modules/Unity/SurfaceManager/mirsurface.cpp	2013-07-19 17:29:44 +0000
+++ src/modules/Unity/SurfaceManager/mirsurface.cpp	2013-07-24 17:24:27 +0000
@@ -6,7 +6,7 @@
 
 namespace mg = mir::geometry;
 
-MirSurface::MirSurface(std::weak_ptr<mir::shell::Surface> surface, QQuickItem *parent)
+MirSurface::MirSurface(std::shared_ptr<mir::shell::Surface> surface, QQuickItem *parent)
     : QQuickItem(parent)
     , m_surface(surface)
 {
@@ -25,22 +25,14 @@
 
 qreal MirSurface::x() const
 {
-    if (auto surface = m_surface.lock()) {
-        int xAbsolute = surface->top_left().x.as_int();
-        return mapFromScene((QPointF(xAbsolute, 0))).x();
-    } else {
-        return 0;
-    }
+    int xAbsolute = m_surface->top_left().x.as_int();
+    return mapFromScene((QPointF(xAbsolute, 0))).x();
 }
 
 qreal MirSurface::y() const
 {
-    if (auto surface = m_surface.lock()) {
-        int yAbsolute = surface->top_left().y.as_int();
-        return mapFromScene((QPointF(0, yAbsolute))).y();
-    } else {
-        return 0;
-    }
+    int yAbsolute = m_surface->top_left().y.as_int();
+    return mapFromScene((QPointF(0, yAbsolute))).y();
 }
 
 void MirSurface::setX(qreal xValue)
@@ -48,13 +40,11 @@
     using namespace mir::geometry;
     qreal xAbsolute = mapToScene(QPointF(xValue, 0)).x();
 
-    if (auto surface = m_surface.lock()) {
-        Point position = surface->top_left();
-        if (position.x.as_int() != (int) xAbsolute) {
-            position.x = X{xAbsolute};
-            surface->move_to(position);
-            Q_EMIT xChanged();
-        }
+    Point position = m_surface->top_left();
+    if (position.x.as_int() != (int) xAbsolute) {
+        position.x = X{xAbsolute};
+        m_surface->move_to(position);
+        Q_EMIT xChanged();
     }
 }
 
@@ -63,45 +53,33 @@
     using namespace mir::geometry;
     qreal yAbsolute = mapToScene(QPointF(0, yValue)).y();
 
-    if (auto surface = m_surface.lock()) {
-        Point position = surface->top_left();
-        if (position.y.as_int() != (int) yAbsolute) {
-            position.y = Y{yAbsolute};
-            surface->move_to(position);
-            Q_EMIT yChanged();
-        }
+    Point position = m_surface->top_left();
+    if (position.y.as_int() != (int) yAbsolute) {
+        position.y = Y{yAbsolute};
+        m_surface->move_to(position);
+        Q_EMIT yChanged();
     }
 }
 
 qreal MirSurface::width() const
 {
-    if (auto surface = m_surface.lock()) {
-        return surface->size().width.as_int();
-    } else {
-        return 0;
-    }
+    return m_surface->size().width.as_int();
 }
 
 qreal MirSurface::height() const
 {
-    if (auto surface = m_surface.lock()) {
-        return surface->size().height.as_int();
-    } else {
-        return 0;
-    }
+    return m_surface->size().height.as_int();
 }
 
 void MirSurface::setWidth(qreal widthValue)
 {
     using namespace mir::geometry;
 
-    if (auto surface = m_surface.lock()) {
-        Size size = surface->size();
-        if (size.width.as_int() != (int) widthValue) {
-            size.width = Width{widthValue};
-//            m_surface->set_size(size); //MISSING FROM API
-            Q_EMIT widthChanged();
-        }
+    Size size = m_surface->size();
+    if (size.width.as_int() != (int) widthValue) {
+        size.width = Width{widthValue};
+//        m_surface->set_size(size); //MISSING FROM API
+        Q_EMIT widthChanged();
     }
 }
 
@@ -109,13 +87,11 @@
 {
     using namespace mir::geometry;
 
-    if (auto surface = m_surface.lock()) {
-        Size size = surface->size();
-        if (size.height.as_int() != (int) heightValue) {
-            size.height = Height{heightValue};
-//            m_surface->set_size(size); //MISSING FROM API
-            Q_EMIT heightChanged();
-        }
+    Size size = m_surface->size();
+    if (size.height.as_int() != (int) heightValue) {
+        size.height = Height{heightValue};
+//        m_surface->set_size(size); //MISSING FROM API
+        Q_EMIT heightChanged();
     }
 }
 
@@ -128,51 +104,38 @@
 {
     if (visible == m_visible) return;
 
-    if (auto surface = m_surface.lock()) {
-        if (visible) {
-            surface->show();
-        } else {
-            surface->hide();
-        }
-        m_visible = visible;
-        Q_EMIT visibleChanged();
+    if (visible) {
+        m_surface->show();
+    } else {
+        m_surface->hide();
     }
+    m_visible = visible;
+    Q_EMIT visibleChanged();
 }
 
 
 MirSurface::Type MirSurface::type() const
-{   //FIXME - how to listen to change in this property
-    if (auto surface = m_surface.lock()) {
-        return static_cast<MirSurface::Type>(surface->type());
-    } else {
-        return Normal;
-    }
+{
+    //FIXME - how to listen to change in this property
+    return static_cast<MirSurface::Type>(m_surface->type());
 }
 
 MirSurface::State MirSurface::state() const
-{   //FIXME - how to listen to change in this property
-    if (auto surface = m_surface.lock()) {
-        return static_cast<MirSurface::State>(surface->state());
-    } else {
-        return Unknown;
-    }
+{
+    //FIXME - how to listen to change in this property
+    return static_cast<MirSurface::State>(m_surface->state());
 }
 
 QString MirSurface::name() const
-{   //FIXME - how to listen to change in this property
-    if (auto surface = m_surface.lock()) {
-        return QString::fromStdString(surface->name());
-    } else {
-        return QString();
-    }
+{
+    //FIXME - how to listen to change in this property
+    return QString::fromStdString(m_surface->name());
 }
 
 void MirSurface::installInputArea(const InputArea* area)
 {
-    if (auto surface = m_surface.lock()) {
-        if (!surface->supports_input()) {
-            DLOG("MirSurface::installInputArea - surface does not support input");
-        }
+    if (!m_surface->supports_input()) {
+        LOG("MirSurface::installInputArea - surface does not support input");
     }
 
     m_inputAreas.push_back(area);
@@ -181,11 +144,7 @@
     /* WARNING: by default, a surface has an input region covering the whole surface.
        Once the surface input region is set, the default will *not* be restored when
        all input regions are removed/disabled */
-    if (auto surface = m_surface.lock()) {
-        surface->set_input_region(m_mirInputAreas);
-    } else {
-        DLOG("MirSurface::installInputArea - unable to set surface input region");
-    }
+    m_surface->set_input_region(m_mirInputAreas);
 }
 
 bool MirSurface::removeInputArea(const InputArea* area)
 
=== modified file 'src/modules/Unity/SurfaceManager/mirsurface.h'
--- src/modules/Unity/SurfaceManager/mirsurface.h	2013-07-19 17:29:44 +0000
+++ src/modules/Unity/SurfaceManager/mirsurface.h	2013-07-24 17:24:27 +0000
@@ -10,6 +10,7 @@
 
 
 namespace mir { namespace geometry { struct Rectangle; }}
+class MirSurfaceManager;
 class InputArea;
 
 class MirSurface : public QQuickItem
@@ -29,7 +30,7 @@
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
 
 public:
-    explicit MirSurface(std::weak_ptr<mir::shell::Surface> surface, QQuickItem *parent = 0);
+    explicit MirSurface(std::shared_ptr<mir::shell::Surface> surface, QQuickItem *parent = 0);
     ~MirSurface();
 
     enum Type {
@@ -81,7 +82,7 @@
     void visibleChanged();
 
 protected:
-    std::weak_ptr<mir::shell::Surface> m_surface;
+    std::shared_ptr<mir::shell::Surface> m_surface;
 
 private:
     // start of methods used by InputFilter
@@ -97,6 +98,7 @@
 
     bool m_visible:true; //FIXME(greyback) state should be in Mir::Shell::Surface, not here
 
+    friend class MirSurfaceManager;
     friend class InputArea;
 };
 
 
=== modified file 'src/modules/Unity/SurfaceManager/mirsurfacemanager.cpp'
--- src/modules/Unity/SurfaceManager/mirsurfacemanager.cpp	2013-07-19 17:29:44 +0000
+++ src/modules/Unity/SurfaceManager/mirsurfacemanager.cpp	2013-07-24 17:24:27 +0000
@@ -5,6 +5,7 @@
 // local
 #include "qmirserverapplication.h"
 #include "shellserverconfiguration.h"
+#include "sessionlistener.h"
 #include "surfacesource.h"
 #include "mirsurfacemanager.h"
 #include "mirsurface.h"
@@ -25,8 +26,10 @@
     }
     m_mirServer = mirServerApplication->server();
 
-    QObject::connect(m_mirServer->surfaceSource(), &SurfaceSource::surfaceCreated,
-                     this, &MirSurfaceManager::mirSurfaceCreated);
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionCreatedSurface,
+                     this, &MirSurfaceManager::sessionCreatedSurface);
+    QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionDestroyingSurface,
+                     this, &MirSurfaceManager::sessionDestroyingSurface);
 }
 
 MirSurfaceManager::~MirSurfaceManager()
@@ -39,11 +42,27 @@
     m_surfaces.clear();
 }
 
-void MirSurfaceManager::mirSurfaceCreated(const std::shared_ptr<msh::Surface> &surface)
+void MirSurfaceManager::sessionCreatedSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const& surface)
 {
-    DLOG("MirSurfaceManager::surfaceCreated (this=%p) with surface name '%s'", this, surface->name().c_str());
+    DLOG("MirSurfaceManager::sessionCreatedSurface (this=%p) with surface name '%s'", this, surface->name().c_str());
     auto qmlSurface = new MirSurface(surface);
 
     m_surfaces.prepend(qmlSurface);
     Q_EMIT surfaceCreated(qmlSurface);
 }
+
+void MirSurfaceManager::sessionDestroyingSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const& surface)
+{
+    DLOG("MirSurfaceManager::sessionDestroyingSurface (this=%p) with surface name '%s'", this, surface->name().c_str());
+
+    Q_FOREACH(MirSurface* s, m_surfaces) {
+        if (s->m_surface == surface) {
+            m_surfaces.removeOne(s);
+            Q_EMIT surfaceDestroyed(s);
+            return;
+        }
+    }
+
+    DLOG("MirSurfaceManager::sessionDestroyingSurface: unable to find MirSurface corresponding to surface '%s'", surface->name().c_str());
+}
+
 
=== modified file 'src/modules/Unity/SurfaceManager/mirsurfacemanager.h'
--- src/modules/Unity/SurfaceManager/mirsurfacemanager.h	2013-07-19 17:29:44 +0000
+++ src/modules/Unity/SurfaceManager/mirsurfacemanager.h	2013-07-24 17:24:27 +0000
@@ -10,7 +10,7 @@
 #include "mirsurface.h"
 
 class ShellServerConfiguration;
-namespace mir { namespace shell { class Surface; }}
+namespace mir { namespace shell { class Surface; class ApplicationSession; }}
 
 class MirSurfaceManager : public QObject
 {
@@ -24,12 +24,13 @@
 
 Q_SIGNALS:
     void surfaceCreated(MirSurface* surface);
-//    void surfaceDestroyed(MirSurface*);
+    void surfaceDestroyed(MirSurface* surface);
 //    void surfaceResized(MirSurface*);
 //    void fullscreenSurfaceChanged();
 
 public Q_SLOTS:
-    void mirSurfaceCreated(const std::shared_ptr<mir::shell::Surface>& surface);
+    void sessionCreatedSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const&);
+    void sessionDestroyingSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const&);
 
 private:
     QList<MirSurface*> m_surfaces;
 
=== modified file 'src/unity-mir/sessionlistener.cpp'
--- src/unity-mir/sessionlistener.cpp	2013-07-19 17:29:44 +0000
+++ src/unity-mir/sessionlistener.cpp	2013-07-24 17:24:27 +0000
@@ -45,3 +45,17 @@
     DLOG("SessionListener::unfocused (this=%p)", this);
     Q_EMIT sessionUnfocused();
 }
+
+void SessionListener::surface_created(msh::Session& session, std::shared_ptr<msh::Surface> const& surface)
+{
+    DLOG("SessionListener::surface_created (this=%p, session=%p, surface=%p)", this, &session, (void*)surface.get());
+    msh::ApplicationSession &appSession = dynamic_cast<msh::ApplicationSession &>(session);
+    Q_EMIT sessionCreatedSurface(&appSession, surface);
+}
+
+void SessionListener::destroying_surface(msh::Session& session, std::shared_ptr<mir::shell::Surface> const& surface)
+{
+    DLOG("SessionListener::destroying_surface (this=%p, session=%p, surface=%p)", this, &session, (void*)surface.get());
+    msh::ApplicationSession &appSession = dynamic_cast<msh::ApplicationSession &>(session);
+    Q_EMIT sessionDestroyingSurface(&appSession, surface);
+}
 
=== modified file 'src/unity-mir/sessionlistener.h'
--- src/unity-mir/sessionlistener.h	2013-07-24 16:34:31 +0000
+++ src/unity-mir/sessionlistener.h	2013-07-24 17:24:27 +0000
@@ -18,14 +18,17 @@
     void focused(std::shared_ptr<mir::shell::Session> const& session) override;
     void unfocused() override;
 
-    void surface_created(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override {}
-    void destroying_surface(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override {}
-    
+    void surface_created(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override;
+    void destroying_surface(mir::shell::Session&, std::shared_ptr<mir::shell::Surface> const&) override;
+
 Q_SIGNALS:
     void sessionStarting(std::shared_ptr<mir::shell::ApplicationSession> const& session);
     void sessionStopping(std::shared_ptr<mir::shell::ApplicationSession> const& session);
     void sessionFocused(std::shared_ptr<mir::shell::ApplicationSession> const& session);
     void sessionUnfocused();
+
+    void sessionCreatedSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const&);
+    void sessionDestroyingSurface(mir::shell::ApplicationSession const*, std::shared_ptr<mir::shell::Surface> const&);
 };
 
 #endif // SESSIONLISTENER_H
 
=== modified file 'src/unity-mir/surfacesource.cpp'
--- src/unity-mir/surfacesource.cpp	2013-07-19 17:29:44 +0000
+++ src/unity-mir/surfacesource.cpp	2013-07-24 17:24:27 +0000
@@ -30,8 +30,6 @@
         m_shellSurface = mirSurface;
         shellSurfaceFound = true;
         Q_EMIT shellSurfaceCreated(mirSurface);
-    } else {
-        Q_EMIT surfaceCreated(mirSurface);
     }
     return mirSurface;
 }
 
=== modified file 'src/unity-mir/surfacesource.h'
--- src/unity-mir/surfacesource.h	2013-07-19 17:29:44 +0000
+++ src/unity-mir/surfacesource.h	2013-07-24 17:24:27 +0000
@@ -27,7 +27,6 @@
     std::shared_ptr<mir::shell::Surface> shellSurface() const;
 
 Q_SIGNALS:
-    void surfaceCreated(std::shared_ptr<mir::shell::Surface> const& surface);
     void shellSurfaceCreated(std::shared_ptr<mir::shell::Surface> const& surface);
 
 private: