Merge lp:~unity-api-team/hud/forward-port into lp:hud/14.10

[Pete Woods]

Forward port trusty SRU

Forward port trusty SRU

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:395
http://jenkins.qa.ubuntu.com/job/hud-ci/289/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-utopic-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-utopic-armhf-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/hud-utopic-i386-ci/4

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

review: Approve (continuous-integration)

[Antti Kaijanmäki (kaijanmaki)]

* Are any changes against your component pending/needed to land the MP under review in a functional state and are those called out explicitly by the submitter?

Only affects HUD.

 * Did you do exploratory testing related to the component you own with the MP changeset included?

Ran the whole TestPlan. Note, HUD is disabled on the phone, so only could do simple smoke test. Desktop testing completed fully.

 * Has the submitter requested review by all the relevant teams/reviewres?
Yes.

 * If you are the reviewer owning the component the MP is against, have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?

This is a forward port of an already accepted SRU.

=== modified file 'data/hud.conf.in'
--- data/hud.conf.in	2013-11-27 14:28:43 +0000
+++ data/hud.conf.in	2014-06-13 07:41:53 +0000
@@ -1,22 +1,10 @@
 description "Unity HUD"
 
-pre-start script
-	if [ -z $DBUS_SESSION_BUS_ADDRESS ]; then
-		echo "Working around missing DBUS_SESSION_BUS_ADDRESS variable"
-		printf "DuplicateSignature\0DBusSessionAddressNotSet" | /usr/share/apport/recoverable_problem -p `pidof -s -o 1 init`
-		. "${HOME}/.cache/upstart/dbus-session"
-		initctl set-env "DBUS_SESSION_BUS_ADDRESS=$DBUS_SESSION_BUS_ADDRESS"
-	fi
-end script
-
 # Currently started by the dbus service file
 # start on dbus-activation com.canonical.hud
 stop on desktop-end
 start on started dbus and ((xsession SESSION=ubuntu-touch) or (xsession SESSION=ubuntu-touch-surfaceflinger) or (xsession SESSION=ubuntu))
 
-env HUD_SERVICE_TIMEOUT=0
-export HUD_SERVICE_TIMEOUT
-
 pre-start script
 	if [ -z $DBUS_SESSION_BUS_ADDRESS ]; then
 		echo "Working around missing DBUS_SESSION_BUS_ADDRESS variable"
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-06-09 14:06:31 +0000
+++ debian/changelog	2014-06-13 07:41:53 +0000
@@ -1,3 +1,21 @@
+hud (14.10-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Pete Woods ]
+  * Forward port changes from trusty.
+
+ -- Pete Woods <[e-mail]>  Fri, 13 Jun 2014 08:22:34 +0100
+
+hud (14.04+14.04.20140604-0ubuntu1) trusty; urgency=medium
+
+  [ Pete Woods ]
+  * Resolve crasher in previous attempted SRU. (LP: #1298656)
+    - Fix order of menu traversal.
+    - Add timeout to legacy HUD queries.
+    - Improve legacy menu safety valve trigger.
+    - Remove duplicate entries in upstart job.
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 04 Jun 2014 14:04:12 +0000
+
 hud (13.10.1+14.10.20140609-0ubuntu1) utopic; urgency=low
 
   [ Ubuntu daily release ]
@@ -8,6 +26,22 @@
 
  -- Ubuntu daily release <[e-mail]>  Mon, 09 Jun 2014 14:06:31 +0000
 
+hud (13.10.1+14.04.20140425-0ubuntu1) trusty; urgency=low
+
+  [ Pete Woods ]
+  * Harden HUD against misbehaving applications Report the offending
+    applications using Apport's recoverable problem tool. Switch to
+    using shared pointers where possible for managing memory. (LP:
+    #1298656)
+
+  [ Marcus Tomlinson ]
+  * Harden HUD against misbehaving applications Report the offending
+    applications using Apport's recoverable problem tool. Switch to
+    using shared pointers where possible for managing memory. (LP:
+    #1298656)
+
+ -- Ubuntu daily release <[e-mail]>  Fri, 25 Apr 2014 08:48:46 +0000
+
 hud (13.10.1+14.04.20140402-0ubuntu2) utopic; urgency=medium
 
   * No-change rebuild for shlib changes in qtbase and qtdeclarative.
 
=== modified file 'libqtgmenu/QtGMenuImporter.cpp'
--- libqtgmenu/QtGMenuImporter.cpp	2014-03-11 05:04:08 +0000
+++ libqtgmenu/QtGMenuImporter.cpp	2014-06-13 07:41:53 +0000
@@ -43,12 +43,12 @@
 {
 }
 
-GMenuModel* QtGMenuImporter::GetGMenuModel() const
+QSharedPointer<GMenuModel> QtGMenuImporter::GetGMenuModel() const
 {
   return d->GetGMenuModel();
 }
 
-GActionGroup* QtGMenuImporter::GetGActionGroup( int index ) const
+QSharedPointer<GActionGroup> QtGMenuImporter::GetGActionGroup( int index ) const
 {
   return d->GetGActionGroup( index );
 }
 
=== modified file 'libqtgmenu/QtGMenuImporter.h'
--- libqtgmenu/QtGMenuImporter.h	2014-03-12 09:04:14 +0000
+++ libqtgmenu/QtGMenuImporter.h	2014-06-13 07:41:53 +0000
@@ -47,8 +47,8 @@
                    const QMap<QString, QDBusObjectPath>& action_paths, QObject* parent = 0 );
   virtual ~QtGMenuImporter();
 
-  GMenuModel* GetGMenuModel() const;
-  GActionGroup* GetGActionGroup( int index = 0 ) const;
+  QSharedPointer<GMenuModel> GetGMenuModel() const;
+  QSharedPointer<GActionGroup> GetGActionGroup( int index = 0 ) const;
 
   std::shared_ptr< QMenu > GetQMenu() const;
 
 
=== modified file 'libqtgmenu/internal/QtGActionGroup.cpp'
--- libqtgmenu/internal/QtGActionGroup.cpp	2014-03-19 23:40:09 +0000
+++ libqtgmenu/internal/QtGActionGroup.cpp	2014-06-13 07:41:53 +0000
@@ -21,13 +21,20 @@
 
 using namespace qtgmenu;
 
-QtGActionGroup::QtGActionGroup( const QString& action_prefix, GActionGroup* action_group )
+QtGActionGroup::QtGActionGroup( QSharedPointer<GDBusConnection> connection,
+        const QString& action_prefix,
+        const QString& service,
+        const QString& path )
     : m_action_prefix( action_prefix ),
-      m_action_group( action_group )
+      m_action_group(
+                G_ACTION_GROUP(
+                        g_dbus_action_group_get(connection.data(),
+                                service.toUtf8().constData(),
+                                path.toUtf8().constData())), &g_object_unref)
 {
   ConnectCallbacks();
 
-  auto actions_list = g_action_group_list_actions( m_action_group );
+  auto actions_list = g_action_group_list_actions( m_action_group.data() );
   if( actions_list )
   {
     for( int i = 0; actions_list[i]; ++i )
@@ -46,7 +53,7 @@
     return;
   }
 
-  auto actions_list = g_action_group_list_actions( m_action_group );
+  auto actions_list = g_action_group_list_actions( m_action_group.data() );
   if( actions_list )
   {
     for( int i = 0; actions_list[i]; ++i )
@@ -58,14 +65,9 @@
   }
 
   DisconnectCallbacks();
-
-  g_object_unref( m_action_group );
-  m_action_group = nullptr;
-
-  return;
 }
 
-GActionGroup* QtGActionGroup::ActionGroup() const
+QSharedPointer<GActionGroup> QtGActionGroup::ActionGroup() const
 {
   return m_action_group;
 }
@@ -83,12 +85,12 @@
   const QString& action(split.second);
   QByteArray action_utf = action.toUtf8();
 
-  const GVariantType* type = g_action_group_get_action_parameter_type( m_action_group,
+  const GVariantType* type = g_action_group_get_action_parameter_type( m_action_group.data(),
 		  action_utf.constData() );
 
   if( type == nullptr )
   {
-    g_action_group_activate_action( m_action_group, action_utf.constData(), nullptr );
+    g_action_group_activate_action( m_action_group.data(), action_utf.constData(), nullptr );
   }
   else
   {
@@ -96,7 +98,7 @@
     if( g_variant_type_equal( type, G_VARIANT_TYPE_STRING ) )
     {
       GVariant* param = g_variant_new_string( action_utf.constData() );
-      g_action_group_activate_action( m_action_group, action_utf.constData(), param );
+      g_action_group_activate_action( m_action_group.data(), action_utf.constData(), param );
       g_variant_unref( param );
     }
   }
@@ -116,21 +118,19 @@
 
 void QtGActionGroup::EmitStates()
 {
-  auto actions_list = g_action_group_list_actions( m_action_group );
+  auto actions_list = g_action_group_list_actions( m_action_group.data() );
 
   for( int i = 0; actions_list && actions_list[i]; ++i )
   {
     gchar* action_name = actions_list[i];
 
-    bool enabled = G_ACTION_GROUP_GET_IFACE( m_action_group ) ->get_action_enabled( m_action_group,
+    bool enabled = G_ACTION_GROUP_GET_IFACE( m_action_group.data() ) ->get_action_enabled( m_action_group.data(),
         action_name );
-    if( !enabled )
-      emit ActionEnabled( FullName(m_action_prefix, action_name), enabled );
+    emit ActionEnabled( FullName(m_action_prefix, action_name), enabled );
 
-    const GVariantType* type = g_action_group_get_action_parameter_type( m_action_group,
+    const GVariantType* type = g_action_group_get_action_parameter_type( m_action_group.data(),
         action_name );
-    if( type != nullptr )
-      emit ActionParameterized( FullName(m_action_prefix, action_name), type != nullptr );
+    emit ActionParameterized( FullName(m_action_prefix, action_name), type != nullptr );
   }
 
   g_strfreev( actions_list );
@@ -142,12 +142,12 @@
   QtGActionGroup* self = reinterpret_cast< QtGActionGroup* >( user_data );
   emit self->ActionAdded( action_name );
 
-  bool enabled = G_ACTION_GROUP_GET_IFACE( self->m_action_group ) ->get_action_enabled(
-      self->m_action_group, action_name );
+  bool enabled = G_ACTION_GROUP_GET_IFACE( self->m_action_group.data() ) ->get_action_enabled(
+      self->m_action_group.data(), action_name );
   if( !enabled )
     emit self->ActionEnabled( FullName(self->m_action_prefix, action_name), enabled );
 
-  const GVariantType* type = g_action_group_get_action_parameter_type( self->m_action_group,
+  const GVariantType* type = g_action_group_get_action_parameter_type( self->m_action_group.data(),
       action_name );
   if( type != nullptr )
     emit self->ActionParameterized( FullName(self->m_action_prefix, action_name), type != nullptr );
@@ -178,22 +178,22 @@
 {
   if( m_action_group && m_action_added_handler == 0 )
   {
-    m_action_added_handler = g_signal_connect( m_action_group, "action-added",
+    m_action_added_handler = g_signal_connect( m_action_group.data(), "action-added",
         G_CALLBACK( ActionAddedCallback ), this );
   }
   if( m_action_group && m_action_removed_handler == 0 )
   {
-    m_action_removed_handler = g_signal_connect( m_action_group, "action-removed",
+    m_action_removed_handler = g_signal_connect( m_action_group.data(), "action-removed",
         G_CALLBACK( ActionRemovedCallback ), this );
   }
   if( m_action_group && m_action_enabled_handler == 0 )
   {
-    m_action_enabled_handler = g_signal_connect( m_action_group, "action-enabled-changed",
+    m_action_enabled_handler = g_signal_connect( m_action_group.data(), "action-enabled-changed",
         G_CALLBACK( ActionEnabledCallback ), this );
   }
   if( m_action_group && m_action_state_changed_handler == 0 )
   {
-    m_action_state_changed_handler = g_signal_connect( m_action_group, "action-state-changed",
+    m_action_state_changed_handler = g_signal_connect( m_action_group.data(), "action-state-changed",
         G_CALLBACK( ActionStateChangedCallback ), this );
   }
 }
@@ -202,19 +202,19 @@
 {
   if( m_action_group && m_action_added_handler != 0 )
   {
-    g_signal_handler_disconnect( m_action_group, m_action_added_handler );
+    g_signal_handler_disconnect( m_action_group.data(), m_action_added_handler );
   }
   if( m_action_group && m_action_removed_handler != 0 )
   {
-    g_signal_handler_disconnect( m_action_group, m_action_removed_handler );
+    g_signal_handler_disconnect( m_action_group.data(), m_action_removed_handler );
   }
   if( m_action_group && m_action_enabled_handler != 0 )
   {
-    g_signal_handler_disconnect( m_action_group, m_action_enabled_handler );
+    g_signal_handler_disconnect( m_action_group.data(), m_action_enabled_handler );
   }
   if( m_action_group && m_action_state_changed_handler != 0 )
   {
-    g_signal_handler_disconnect( m_action_group, m_action_state_changed_handler );
+    g_signal_handler_disconnect( m_action_group.data(), m_action_state_changed_handler );
   }
 
   m_action_added_handler = 0;
 
=== modified file 'libqtgmenu/internal/QtGActionGroup.h'
--- libqtgmenu/internal/QtGActionGroup.h	2014-03-19 23:40:09 +0000
+++ libqtgmenu/internal/QtGActionGroup.h	2014-06-13 07:41:53 +0000
@@ -20,6 +20,7 @@
 #define QTGACTIONGROUP_H
 
 #include <QObject>
+#include <QSharedPointer>
 #include <QVariant>
 
 #undef signals
@@ -33,10 +34,13 @@
 Q_OBJECT
 
 public:
-  QtGActionGroup( const QString& action_prefix, GActionGroup* action_group );
+  QtGActionGroup(QSharedPointer<GDBusConnection> connection,
+            const QString& action_prefix,
+            const QString& service,
+            const QString& path);
   virtual ~QtGActionGroup();
 
-  GActionGroup* ActionGroup() const;
+  QSharedPointer<GActionGroup> ActionGroup() const;
 
 Q_SIGNALS:
   void ActionAdded( QString action_name );
@@ -66,7 +70,7 @@
 private:
 
   QString m_action_prefix;
-  GActionGroup* m_action_group = nullptr;
+  QSharedPointer<GActionGroup> m_action_group;
 
   gulong m_action_added_handler = 0;
   gulong m_action_removed_handler = 0;
 
=== modified file 'libqtgmenu/internal/QtGMenuImporterPrivate.cpp'
--- libqtgmenu/internal/QtGMenuImporterPrivate.cpp	2014-03-19 23:26:48 +0000
+++ libqtgmenu/internal/QtGMenuImporterPrivate.cpp	2014-06-13 07:41:53 +0000
@@ -30,7 +30,7 @@
       m_service_watcher( service, QDBusConnection::sessionBus(),
           QDBusServiceWatcher::WatchForOwnerChange ),
       m_parent( parent ),
-      m_connection( g_bus_get_sync( G_BUS_TYPE_SESSION, NULL, NULL ) ),
+      m_connection( g_bus_get_sync( G_BUS_TYPE_SESSION, NULL, NULL ), &g_object_unref ),
       m_service( service ),
       m_menu_path( menu_path ),
       m_action_paths( action_paths )
@@ -48,26 +48,24 @@
 {
   ClearMenuModel();
   ClearActionGroups();
-
-  g_object_unref( m_connection );
 }
 
-GMenuModel* QtGMenuImporterPrivate::GetGMenuModel()
+QSharedPointer<GMenuModel> QtGMenuImporterPrivate::GetGMenuModel()
 {
   if( m_menu_model == nullptr )
   {
-    return nullptr;
+    return QSharedPointer<GMenuModel>();
   }
 
   return m_menu_model->Model();
 }
 
-GActionGroup* QtGMenuImporterPrivate::GetGActionGroup( int index )
+QSharedPointer<GActionGroup> QtGMenuImporterPrivate::GetGActionGroup( int index )
 {
   if( index >= m_action_groups.size() ||
       m_action_groups[index] == nullptr )
   {
-    return nullptr;
+    return QSharedPointer<GActionGroup>();
   }
 
   return m_action_groups[index]->ActionGroup();
@@ -160,13 +158,12 @@
   ClearMenuModel();
 
   QString menu_path = m_menu_path.path();
-  m_menu_model =
-      std::make_shared< QtGMenuModel > (
-              G_MENU_MODEL( g_dbus_menu_model_get( m_connection, m_service.toUtf8().constData(), menu_path.toUtf8().constData() ) ),
-              m_service, menu_path, m_action_paths );
+  m_menu_model = std::make_shared< QtGMenuModel > ( m_connection, m_service, menu_path, m_action_paths );
 
   connect( m_menu_model.get(), SIGNAL( MenuItemsChanged( QtGMenuModel*, int, int,
           int ) ), &m_parent, SIGNAL( MenuItemsChanged()) );
+
+  connect( m_menu_model.get(), SIGNAL( MenuInvalid() ), this, SLOT( MenuInvalid() ) );
 }
 
 void QtGMenuImporterPrivate::RefreshGActionGroup()
@@ -181,8 +178,8 @@
 
     QString action_path = action_path_it.value().path();
     m_action_groups.push_back(
-        std::make_shared< QtGActionGroup > ( action_path_it.key(),
-                G_ACTION_GROUP( g_dbus_action_group_get( m_connection, m_service.toUtf8().constData(), action_path.toUtf8().constData() ) ) ) );
+                std::make_shared<QtGActionGroup>(m_connection,
+                        action_path_it.key(), m_service, action_path));
 
     auto action_group = m_action_groups.back();
 
@@ -198,3 +195,14 @@
 
   LinkMenuActions();
 }
+
+void QtGMenuImporterPrivate::MenuInvalid()
+{
+  disconnect( &m_service_watcher, SIGNAL( serviceRegistered( const QString& ) ), this,
+        SLOT( ServiceRegistered() ) );
+
+  disconnect( &m_service_watcher, SIGNAL( serviceUnregistered( const QString& ) ), this,
+        SLOT( ServiceUnregistered() ) );
+
+  ServiceUnregistered();
+}
 
=== modified file 'libqtgmenu/internal/QtGMenuImporterPrivate.h'
--- libqtgmenu/internal/QtGMenuImporterPrivate.h	2014-03-19 23:26:48 +0000
+++ libqtgmenu/internal/QtGMenuImporterPrivate.h	2014-06-13 07:41:53 +0000
@@ -43,8 +43,8 @@
                           const QMap<QString, QDBusObjectPath>& action_paths, QtGMenuImporter& parent );
   virtual ~QtGMenuImporterPrivate();
 
-  GMenuModel* GetGMenuModel();
-  GActionGroup* GetGActionGroup( int index = 0);
+  QSharedPointer<GMenuModel> GetGMenuModel();
+  QSharedPointer<GActionGroup> GetGActionGroup( int index = 0);
 
   std::shared_ptr< QMenu > GetQMenu();
 
@@ -62,13 +62,14 @@
 
   void RefreshGMenuModel();
   void RefreshGActionGroup();
+  void MenuInvalid();
 
 private:
   QDBusServiceWatcher m_service_watcher;
 
   QtGMenuImporter& m_parent;
 
-  GDBusConnection* m_connection;
+  QSharedPointer<GDBusConnection> m_connection;
   QString m_service;
   QDBusObjectPath m_menu_path;
   QMap<QString, QDBusObjectPath> m_action_paths;
 
=== modified file 'libqtgmenu/internal/QtGMenuModel.cpp'
--- libqtgmenu/internal/QtGMenuModel.cpp	2014-03-19 23:26:48 +0000
+++ libqtgmenu/internal/QtGMenuModel.cpp	2014-06-13 07:41:53 +0000
@@ -18,44 +18,52 @@
 
 #include <QtGMenuModel.h>
 #include <QtGMenuUtils.h>
+#include <QCoreApplication>
+#include <QDBusConnection>
+#include <QDBusConnectionInterface>
 #include <QDebug>
+#include <QProcess>
+#include <QRegularExpression>
 
 using namespace qtgmenu;
 
-QtGMenuModel::QtGMenuModel( GMenuModel* model )
-    : QtGMenuModel( model, LinkType::Root, nullptr, 0 )
-{
-}
+static const QRegularExpression SINGLE_UNDERSCORE("(?<![_])[_](?![_])");
 
-QtGMenuModel::QtGMenuModel( GMenuModel* model, const QString& bus_name, const QString& menu_path, const QMap<QString, QDBusObjectPath>& action_paths )
-    : QtGMenuModel( model, LinkType::Root, nullptr, 0 )
+QtGMenuModel::QtGMenuModel( QSharedPointer<GDBusConnection> connection, const QString& bus_name,
+                            const QString& menu_path, const QMap<QString, QDBusObjectPath>& action_paths )
+    : QtGMenuModel( QSharedPointer<GMenuModel>(G_MENU_MODEL( g_dbus_menu_model_get( connection.data(),
+                                                         bus_name.toUtf8().constData(),
+                                                         menu_path.toUtf8().constData() ) ), &g_object_unref ),
+                    LinkType::Root, nullptr, 0 )
 {
+  m_connection = connection;
   m_bus_name = bus_name;
   m_menu_path = menu_path;
   m_action_paths = action_paths;
 }
 
-QtGMenuModel::QtGMenuModel( GMenuModel* model, LinkType link_type, QtGMenuModel* parent, int index )
+QtGMenuModel::QtGMenuModel( QSharedPointer<GMenuModel> model, LinkType link_type, QtGMenuModel* parent, int index )
     : m_parent( parent ),
       m_model( model ),
-      m_link_type( link_type )
+      m_link_type( link_type ),
+      m_menu( new QMenu() ),
+      m_ext_menu( new QMenu() )
 {
   ConnectCallback();
 
   if( m_parent )
   {
-    m_parent->InsertChild( this, index );
-
+    m_connection = m_parent->m_connection;
     m_bus_name = m_parent->m_bus_name;
     m_menu_path = m_parent->m_menu_path;
     m_action_paths = m_parent->m_action_paths;
 
     gchar* label = NULL;
-    if( g_menu_model_get_item_attribute( m_parent->m_model, index,
+    if( g_menu_model_get_item_attribute( m_parent->m_model.data(), index,
             G_MENU_ATTRIBUTE_LABEL, "s", &label ) )
     {
       QString qlabel = QString::fromUtf8( label );
-      qlabel.replace( '_', '&' );
+      qlabel.replace( SINGLE_UNDERSCORE, "&" );
       g_free( label );
 
       m_ext_menu->setTitle( qlabel );
@@ -63,7 +71,7 @@
 
     gchar* action_name = NULL;
     QString qaction_name;
-    if( g_menu_model_get_item_attribute( m_parent->m_model, index,
+    if( g_menu_model_get_item_attribute( m_parent->m_model.data(), index,
             G_MENU_ATTRIBUTE_ACTION, "s", &action_name ) )
     {
       qaction_name = QString::fromUtf8( action_name );
@@ -74,7 +82,7 @@
 
     // if this model has a "commitLabel" property, it is a libhud parameterized action
     gchar* commit_label = NULL;
-    if( g_menu_model_get_item_attribute( m_parent->m_model, index,
+    if( g_menu_model_get_item_attribute( m_parent->m_model.data(), index,
             "commitLabel", "s", &commit_label ) )
     {
       g_free( commit_label );
@@ -100,7 +108,7 @@
 
   if( m_model )
   {
-    m_size = g_menu_model_get_n_items( m_model );
+    m_size = g_menu_model_get_n_items( m_model.data() );
   }
 
   ChangeMenuItems( 0, m_size, 0 );
@@ -112,23 +120,15 @@
   {
     if( m_size > 0 )
     {
-      MenuItemsChangedCallback( m_model, 0, m_size, 0, this );
+      ChangeMenuItems( 0, 0, m_size );
     }
     DisconnectCallback();
-    g_object_unref( m_model );
   }
 
-  for( auto child : m_children )
-  {
-    delete child;
-  }
   m_children.clear();
-
-  delete m_menu;
-  delete m_ext_menu;
 }
 
-GMenuModel* QtGMenuModel::Model() const
+QSharedPointer<GMenuModel> QtGMenuModel::Model() const
 {
   return m_model;
 }
@@ -138,24 +138,19 @@
   return m_link_type;
 }
 
-int QtGMenuModel::Size() const
-{
-  return m_size;
-}
-
 QtGMenuModel* QtGMenuModel::Parent() const
 {
   return m_parent;
 }
 
-QtGMenuModel* QtGMenuModel::Child( int index ) const
+QSharedPointer<QtGMenuModel> QtGMenuModel::Child( int index ) const
 {
   if( m_children.contains( index ) )
   {
     return m_children.value( index );
   }
 
-  return nullptr;
+  return QSharedPointer<QtGMenuModel>();
 }
 
 std::shared_ptr< QMenu > QtGMenuModel::GetQMenu()
@@ -178,7 +173,10 @@
   auto action_it = m_actions.find( action_name );
   if( action_it != end( m_actions ) )
   {
-    action_it->second->setEnabled( enabled );
+    for( auto& action : action_it->second )
+    {
+      action->setEnabled( enabled );
+    }
   }
 }
 
@@ -187,78 +185,122 @@
   auto action_it = m_actions.find( action_name );
   if( action_it != end( m_actions ) )
   {
-    action_it->second->setProperty( c_property_isParameterized, parameterized );
+    for( auto& action : action_it->second )
+    {
+      action->setProperty( c_property_isParameterized, parameterized );
+    }
   }
 }
 
-QtGMenuModel* QtGMenuModel::CreateChild( QtGMenuModel* parent, GMenuModel* model, int index )
+QSharedPointer<QtGMenuModel> QtGMenuModel::CreateChild( QtGMenuModel* parent_qtgmenu, QSharedPointer<GMenuModel> parent_gmenu, int child_index )
 {
-  LinkType linkType( LinkType::SubMenu );
-  GMenuModel* link = g_menu_model_get_item_link( model, index, G_MENU_LINK_SUBMENU );
-
-  if( !link )
-  {
-    linkType = LinkType::Section;
-    link = g_menu_model_get_item_link( model, index, G_MENU_LINK_SECTION );
-  }
-
-  if( link )
-  {
-    return new QtGMenuModel( link, linkType, parent, index );
-  }
-
-  return nullptr;
+  QSharedPointer<QtGMenuModel> new_child;
+
+  GMenuLinkIter* link_it = g_menu_model_iterate_item_links( parent_gmenu.data(), child_index );
+
+  // get the first link, if it exists, create the child accordingly
+  if( link_it && g_menu_link_iter_next( link_it ) )
+  {
+    // if link is a sub menu
+    if( strcmp( g_menu_link_iter_get_name( link_it ), G_MENU_LINK_SUBMENU ) == 0 )
+    {
+      new_child.reset(
+                new QtGMenuModel(
+                        QSharedPointer<GMenuModel>(
+                                g_menu_link_iter_get_value(link_it),
+                                &g_object_unref), LinkType::SubMenu,
+                        parent_qtgmenu, child_index));
+    }
+    // else if link is a section
+    else if( strcmp( g_menu_link_iter_get_name( link_it ), G_MENU_LINK_SECTION ) == 0 )
+    {
+      new_child.reset(
+                    new QtGMenuModel(
+                            QSharedPointer<GMenuModel>(
+                                    g_menu_link_iter_get_value(link_it),
+                                    &g_object_unref), LinkType::Section,
+                            parent_qtgmenu, child_index));
+    }
+  }
+
+  g_object_unref( link_it );
+  return new_child;
 }
 
 void QtGMenuModel::MenuItemsChangedCallback( GMenuModel* model, gint index, gint removed,
     gint added, gpointer user_data )
 {
   QtGMenuModel* self = reinterpret_cast< QtGMenuModel* >( user_data );
+
+  if( self->m_model != model )
+  {
+    qWarning() << "\"items-changed\" signal received from an unrecognised menu model";
+    return;
+  }
+
   self->ChangeMenuItems( index, added, removed );
 }
 
-void QtGMenuModel::ChangeMenuItems( int index, int added, int removed )
+void QtGMenuModel::ChangeMenuItems( const int index, const int added, const int removed )
 {
+  const int n_items = g_menu_model_get_n_items( m_model.data() );
+
+  if( index < 0 || added < 0 || removed < 0 || index + added > n_items || index + removed > m_size )
+  {
+    ReportRecoverableError(index, added, removed);
+    return;
+  }
+
+  // process removed items first (see "items-changed" on the GMenuModel man page)
   if( removed > 0 )
   {
+    // remove QAction from 'index' of our QMenu, 'removed' times
     for( int i = 0; i < removed; ++i )
     {
       if( index < m_menu->actions().size() )
       {
         QAction* at_action = m_menu->actions().at( index );
-        ActionRemoved( at_action->property( c_property_actionName ).toString() );
+        ActionRemoved( at_action->property( c_property_actionName ).toString(), at_action );
         m_menu->removeAction( at_action );
       }
     }
 
+    // update m_children
     for( int i = index; i < m_size; ++i )
     {
-      if( i <= ( index + removed ) )
+      // remove children from index until ( index + removed )
+      if( i < ( index + removed ) )
       {
-        delete m_children.take( i );
+        m_children.take( i );
       }
+      // shift children from ( index + removed ) to m_size into the now empty positions
       else if( m_children.contains( i ) )
       {
         m_children.insert( i - removed, m_children.take( i ) );
       }
     }
 
+    // update m_size
     m_size -= removed;
   }
 
+  // now process added items
   if( added > 0 )
   {
-    // shift items up
-    for( int i = ( m_size + added ) - 1; i >= index; --i )
+    // update m_children (start from the end and work backwards as not to overlap items as we shift them up)
+    for( int i = m_size - 1; i >= index; --i )
     {
+      // shift 'added' items up from their current index to ( index + added )
       if( m_children.contains( i ) )
       {
         m_children.insert( i + added, m_children.take( i ) );
       }
     }
 
+    // update m_size
     m_size += added;
 
+    // now add a new QAction to our QMenu for each new item
     for( int i = index; i < ( index + added ); ++i )
     {
       QAction* at_action = nullptr;
@@ -267,32 +309,37 @@
         at_action = m_menu->actions().at( i );
       }
 
-      QtGMenuModel* model = CreateChild( this, m_model, i );
+      // try first to create a child model
+      QSharedPointer< QtGMenuModel > model = CreateChild( this, m_model, i );
 
+      // if this is a menu item and not a model
       if( !model )
       {
         QAction* new_action = CreateAction( i );
         ActionAdded( new_action->property( c_property_actionName ).toString(), new_action );
         m_menu->insertAction( at_action, new_action );
       }
+      // else if this is a section model
       else if( model->Type() == LinkType::Section )
       {
+        InsertChild( model, i );
         m_menu->insertSeparator( at_action );
       }
+      // else if this is a sub menu model
       else if( model->Type() == LinkType::SubMenu )
       {
-        m_menu->insertMenu( at_action, model->m_ext_menu );
+        InsertChild( model, i );
+        ActionAdded( model->m_ext_menu->menuAction()->property( c_property_actionName ).toString(),
+                     model->m_ext_menu->menuAction() );
+        m_menu->insertMenu( at_action, model->m_ext_menu.data() );
       }
     }
   }
 
   // update external menu
   UpdateExtQMenu();
-  if( m_link_type == LinkType::Section && m_parent )
-  {
-    m_parent->UpdateExtQMenu();
-  }
 
+  // now tell the outside world that items have changed
   emit MenuItemsChanged( this, index, removed, added );
 }
 
@@ -300,7 +347,7 @@
 {
   if( m_model && m_items_changed_handler == 0 )
   {
-    m_items_changed_handler = g_signal_connect( m_model, "items-changed",
+    m_items_changed_handler = g_signal_connect( m_model.data(), "items-changed",
         G_CALLBACK( MenuItemsChangedCallback ), this );
   }
 }
@@ -309,13 +356,13 @@
 {
   if( m_model && m_items_changed_handler != 0 )
   {
-    g_signal_handler_disconnect( m_model, m_items_changed_handler );
+    g_signal_handler_disconnect( m_model.data(), m_items_changed_handler );
   }
 
   m_items_changed_handler = 0;
 }
 
-void QtGMenuModel::InsertChild( QtGMenuModel* child, int index )
+void QtGMenuModel::InsertChild( QSharedPointer<QtGMenuModel> child, int index )
 {
   if( m_children.contains( index ) )
   {
@@ -325,35 +372,27 @@
   child->m_parent = this;
   m_children.insert( index, child );
 
-  connect( child, SIGNAL( MenuItemsChanged( QtGMenuModel*, int, int, int ) ), this,
+  connect( child.data(), SIGNAL( MenuItemsChanged( QtGMenuModel*, int, int, int ) ), this,
       SIGNAL( MenuItemsChanged( QtGMenuModel*, int, int, int ) ) );
 
-  connect( child, SIGNAL( ActionTriggered( QString, bool ) ), this,
+  connect( child.data(), SIGNAL( ActionTriggered( QString, bool ) ), this,
       SIGNAL( ActionTriggered( QString, bool ) ) );
-}
-
-int QtGMenuModel::ChildIndex( QtGMenuModel* child )
-{
-  for( int i = 0; i < m_children.size(); ++i )
-  {
-    if( child == m_children[i] )
-    {
-      return i;
-    }
-  }
-
-  return -1;
+
+  connect( child.data(), SIGNAL( MenuInvalid() ), this, SIGNAL( MenuInvalid() ) );
+
+  // emit signal informing subscribers that this child has added all of its menu items
+  emit MenuItemsChanged( child.data(), 0, 0, child->m_size );
 }
 
 QAction* QtGMenuModel::CreateAction( int index )
 {
+  QAction* action = new QAction( m_menu.data() );
+
   // action label
-  QAction* action = new QAction( this );
-
   gchar* label = NULL;
-  if( g_menu_model_get_item_attribute( m_model, index, G_MENU_ATTRIBUTE_LABEL, "s", &label ) ) {
+  if( g_menu_model_get_item_attribute( m_model.data(), index, G_MENU_ATTRIBUTE_LABEL, "s", &label ) ) {
     QString qlabel = QString::fromUtf8( label );
-    qlabel.replace( '_', '&' );
+    qlabel.replace( SINGLE_UNDERSCORE, "&" );
     g_free( label );
 
     action->setText( qlabel );
@@ -361,7 +400,7 @@
 
   // action name
   gchar* action_name = NULL;
-  if( g_menu_model_get_item_attribute( m_model, index,
+  if( g_menu_model_get_item_attribute( m_model.data(), index,
 	      G_MENU_ATTRIBUTE_ACTION, "s", &action_name ) )
   {
     QString qaction_name = QString::fromUtf8( action_name );
@@ -378,7 +417,7 @@
   action->setProperty( c_property_menuPath, m_menu_path );
 
   // action icon
-  GVariant* icon = g_menu_model_get_item_attribute_value( m_model, index, G_MENU_ATTRIBUTE_ICON,
+  GVariant* icon = g_menu_model_get_item_attribute_value( m_model.data(), index, G_MENU_ATTRIBUTE_ICON,
       G_VARIANT_TYPE_VARIANT );
 
   if( icon )
@@ -388,7 +427,7 @@
 
   // action shortcut
   gchar* shortcut = NULL;
-  if( g_menu_model_get_item_attribute( m_model, index, "accel", "s", &shortcut ) )
+  if( g_menu_model_get_item_attribute( m_model.data(), index, "accel", "s", &shortcut ) )
   {
     QString qshortcut = QString::fromUtf8( shortcut );
     g_free( shortcut );
@@ -398,7 +437,7 @@
 
   // action shortcut
   gchar* toolbar_item = NULL;
-  if( g_menu_model_get_item_attribute( m_model, index, c_property_hud_toolbar_item, "s", &toolbar_item ) )
+  if( g_menu_model_get_item_attribute( m_model.data(), index, c_property_hud_toolbar_item, "s", &toolbar_item ) )
   {
     QString qtoolbar_item = QString::fromUtf8( toolbar_item );
     g_free( toolbar_item );
@@ -408,7 +447,7 @@
 
   // action keywords
   gchar* keywords = NULL;
-  if( g_menu_model_get_item_attribute( m_model, index, c_property_keywords, "s", &keywords ) )
+  if( g_menu_model_get_item_attribute( m_model.data(), index, c_property_keywords, "s", &keywords ) )
   {
     QVariant qkeywords = QString::fromUtf8( keywords );
     g_free( keywords );
@@ -458,14 +497,13 @@
 
     if( action->isSeparator() )
     {
-      QtGMenuModel* child = Child( i );
+      QSharedPointer<QtGMenuModel> child = Child( i );
       if( !child || child->Type() != LinkType::Section )
       {
         continue;
       }
-      QMenu* section = child->m_ext_menu;
 
-      for( QAction* sub_action : section->actions() )
+      for( QAction* sub_action : child->m_ext_menu->actions() )
       {
         m_ext_menu->addAction( sub_action );
       }
@@ -485,6 +523,12 @@
       m_ext_menu->removeAction( last_action );
     }
   }
+
+  // if this is a section within a parent menu, we need to update the parent menu as well
+  if( m_link_type == LinkType::Section && m_parent )
+  {
+    m_parent->UpdateExtQMenu();
+  }
 }
 
 void QtGMenuModel::ActionAdded( const QString& name, QAction* action )
@@ -494,17 +538,205 @@
   {
     m_parent->ActionAdded( name, action );
   }
-
-  m_actions[name] = action;
+  else
+  {
+    // check if the action name is already in our map
+    if( m_actions.find( name ) != m_actions.end() )
+    {
+      // add the QAction pointer to the list of actions under this name
+      m_actions[name].push_back( action );
+    }
+    else
+    {
+      // otherwise insert the new action into the map
+      m_actions.insert( std::make_pair( name, std::vector< QAction* >{ action } ) );
+    }
+  }
 }
 
-void QtGMenuModel::ActionRemoved( const QString& name )
+void QtGMenuModel::ActionRemoved( const QString& name, QAction* action )
 {
   // remove action from top menu's m_actions
   if( m_parent )
   {
-    m_parent->ActionRemoved( name );
-  }
-
-  m_actions.erase( name );
+    m_parent->ActionRemoved( name, action );
+  }
+  else
+  {
+    // check if this action is actually in our map
+    if( m_actions.find( name ) != m_actions.end() )
+    {
+      // remove the QAction pointer from the list of actions under this name
+      auto& actionList = m_actions[name];
+      auto actionIt = std::find( actionList.begin(), actionList.end(), action );
+
+      if( actionIt != actionList.end())
+      {
+        actionList.erase( actionIt );
+      }
+
+      // if there are no more references to this action, remove it from the map
+      if( actionList.size() == 0 )
+      {
+        m_actions.erase( name );
+      }
+    }
+  }
+}
+
+static void write_pair(QIODevice& device, const QString& key, const QString& value, bool last = false)
+{
+  device.write(key.toUtf8());
+  device.write("", 1);
+  device.write(value.toUtf8());
+  if( !last )
+  {
+    device.write("", 1);
+  }
+
+  if( !value.isEmpty())
+  {
+    qWarning() << key << " =" << value;
+  }
+}
+
+void QtGMenuModel::ReportRecoverableError(const int index, const int added, const int removed)
+{
+  if( m_error_reported )
+  {
+    return;
+  }
+
+  // gmenumodel properties
+  int gmenu_item_count = 0;
+  QString gmenu_action_names;
+
+  gmenu_item_count = g_menu_model_get_n_items( m_model.data() );
+
+  qWarning() << "Illegal arguments when updating GMenuModel: position ="
+             << index << ", added =" << added << ", removed =" << removed
+             << ", size =" << gmenu_item_count;
+
+  for( int i = 0; i < gmenu_item_count; ++i )
+  {
+    gchar* action_name = NULL;
+    if( g_menu_model_get_item_attribute( m_model.data(), i,
+          G_MENU_ATTRIBUTE_ACTION, "s", &action_name ) )
+    {
+      gmenu_action_names += action_name;
+      gmenu_action_names += ";";
+      g_free( action_name );
+    }
+  }
+
+  // parent model properties
+  QString parent_menu_label;
+  QString parent_menu_name;
+  QString parent_action_names;
+  QString parent_link_type;
+
+  if( m_parent )
+  {
+    parent_menu_label = m_parent->m_menu->menuAction()->text();
+    parent_menu_name = m_parent->m_menu->menuAction()->property( c_property_actionName ).toString();
+
+    for( QAction* action : m_parent->m_menu->actions() )
+    {
+      parent_action_names += action->property( c_property_actionName ).toString() + ";";
+    }
+
+    switch( m_parent->m_link_type )
+    {
+    case LinkType::Root:
+      parent_link_type = "root";
+      break;
+    case LinkType::Section:
+      parent_link_type = "section";
+      break;
+    case LinkType::SubMenu:
+      parent_link_type = "sub menu";
+      break;
+    }
+  }
+
+  // local model properties
+  QString menu_label;
+  QString menu_name;
+  QString action_names;
+  QString link_type;
+  QString action_paths;
+
+  menu_label = m_menu->menuAction()->text();
+  menu_name = m_menu->menuAction()->property( c_property_actionName ).toString();
+  for( QAction* action : m_menu->actions() )
+  {
+    action_names += action->property( c_property_actionName ).toString() + ";";
+  }
+
+  switch( m_link_type )
+  {
+  case LinkType::Root:
+    link_type = "root";
+    break;
+  case LinkType::Section:
+    link_type = "section";
+    break;
+  case LinkType::SubMenu:
+    link_type = "sub menu";
+    break;
+  }
+
+  for( auto const& action : m_action_paths )
+  {
+    action_paths += action.path() + ";";
+  }
+
+  uint sender_pid = QDBusConnection::sessionBus().interface()->servicePid(
+            m_bus_name);
+  if( sender_pid == 0 ) {
+      qWarning() << "Failed to read PID, cannot report error";
+      return;
+  }
+
+  QProcess recoverable;
+  recoverable.setProcessChannelMode(QProcess::ForwardedChannels);
+  recoverable.start("/usr/share/apport/recoverable_problem",
+              QStringList() << "-p" << QString::number(sender_pid));
+  if (recoverable.waitForStarted())
+  {
+    write_pair(recoverable, "DuplicateSignature", "GMenuModelItemsChangedInvalidIndex");
+    write_pair(recoverable, "BusName", m_bus_name);
+    write_pair(recoverable, "Position", QString::number(index));
+    write_pair(recoverable, "Added", QString::number(added));
+    write_pair(recoverable, "Removed", QString::number(removed));
+    write_pair(recoverable, "ItemCount", QString::number(gmenu_item_count));
+    write_pair(recoverable, "ActionNames", gmenu_action_names);
+
+    if ( m_parent )
+    {
+      write_pair(recoverable, "ParentMenuLabel", parent_menu_label);
+      write_pair(recoverable, "ParentMenuName", parent_menu_name);
+      write_pair(recoverable, "ParentActionNames", parent_action_names);
+      write_pair(recoverable, "ParentLinkType", parent_link_type);
+    }
+
+    write_pair(recoverable, "MenuLabel", menu_label);
+    write_pair(recoverable, "MenuName", menu_name);
+    write_pair(recoverable, "ActionNames", action_names);
+    write_pair(recoverable, "LinkType", link_type);
+
+    write_pair(recoverable, "MenuPath", m_menu_path);
+    write_pair(recoverable, "ActionPaths", action_paths, true);
+
+    recoverable.closeWriteChannel();
+    recoverable.waitForFinished();
+
+    m_error_reported = true;
+  }
+  else
+  {
+    qWarning() << "Failed to report recoverable error";
+  }
+
+  emit MenuInvalid();
 }
 
=== modified file 'libqtgmenu/internal/QtGMenuModel.h'
--- libqtgmenu/internal/QtGMenuModel.h	2014-03-19 23:26:48 +0000
+++ libqtgmenu/internal/QtGMenuModel.h	2014-06-13 07:41:53 +0000
@@ -43,17 +43,14 @@
     Root, Section, SubMenu
   };
 
-  explicit QtGMenuModel( GMenuModel* model );
-  QtGMenuModel( GMenuModel* model, const QString& bus_name, const QString& menu_path, const QMap<QString, QDBusObjectPath>& action_paths );
+  QtGMenuModel( QSharedPointer<GDBusConnection> connection, const QString& bus_name, const QString& menu_path, const QMap<QString, QDBusObjectPath>& action_paths );
   virtual ~QtGMenuModel();
 
-  GMenuModel* Model() const;
+  QSharedPointer<GMenuModel> Model() const;
   LinkType Type() const;
 
-  int Size() const;
-
   QtGMenuModel* Parent() const;
-  QtGMenuModel* Child( int index ) const;
+  QSharedPointer<QtGMenuModel> Child( int index ) const;
 
   std::shared_ptr< QMenu > GetQMenu();
 
@@ -68,6 +65,7 @@
 Q_SIGNALS:
   void MenuItemsChanged( QtGMenuModel* model, int index, int removed, int added );
   void ActionTriggered( QString action_name, bool checked );
+  void MenuInvalid();
 
 public Q_SLOTS:
   void ActionEnabled( QString action_name, bool enabled );
@@ -77,20 +75,19 @@
   void ActionTriggered( bool );
 
 private:
-  QtGMenuModel( GMenuModel* model, LinkType link_type, QtGMenuModel* parent, int index );
+  QtGMenuModel( QSharedPointer<GMenuModel> model, LinkType link_type, QtGMenuModel* parent, int index );
 
-  static QtGMenuModel* CreateChild( QtGMenuModel* parent, GMenuModel* model, int index );
+  static QSharedPointer<QtGMenuModel> CreateChild( QtGMenuModel* parent_qtgmenu, QSharedPointer<GMenuModel> parent_gmenu, int child_index );
 
   static void MenuItemsChangedCallback( GMenuModel* model, gint index, gint removed, gint added,
       gpointer user_data );
 
-  void ChangeMenuItems( int index, int added, int removed );
+  void ChangeMenuItems( const int index, const int added, const int removed );
 
   void ConnectCallback();
   void DisconnectCallback();
 
-  void InsertChild( QtGMenuModel* child, int index );
-  int ChildIndex( QtGMenuModel* child );
+  void InsertChild( QSharedPointer<QtGMenuModel> child, int index );
 
   QAction* CreateAction( int index );
 
@@ -98,26 +95,32 @@
   void UpdateExtQMenu();
 
   void ActionAdded( const QString& name, QAction* action );
-  void ActionRemoved( const QString& name );
+  void ActionRemoved( const QString& name, QAction* action );
+
+  void ReportRecoverableError(const int index, const int added, const int removed);
 
 private:
   QtGMenuModel* m_parent = nullptr;
-  QMap< int, QtGMenuModel* > m_children;
+  QMap< int, QSharedPointer<QtGMenuModel>> m_children;
 
-  GMenuModel* m_model = nullptr;
+  QSharedPointer<GMenuModel> m_model;
   gulong m_items_changed_handler = 0;
 
   LinkType m_link_type;
   int m_size = 0;
 
-  QMenu* m_menu = new QMenu();
-  QMenu* m_ext_menu = new QMenu();
+  QScopedPointer<QMenu> m_menu;
+  QScopedPointer<QMenu> m_ext_menu;
 
+  QSharedPointer<GDBusConnection> m_connection;
   QString m_bus_name;
   QString m_menu_path;
   QMap<QString, QDBusObjectPath> m_action_paths;
 
-  std::map< QString, QAction* > m_actions;
+  // a map of QActions indexed by their name and stored with a reference count
+  std::map< QString, std::vector< QAction* > > m_actions;
+
+  bool m_error_reported = false;
 };
 
 } // namespace qtgmenu
 
=== modified file 'service/DBusMenuCollector.cpp'
--- service/DBusMenuCollector.cpp	2014-04-01 13:13:04 +0000
+++ service/DBusMenuCollector.cpp	2014-06-13 07:41:53 +0000
@@ -82,25 +82,18 @@
 	return !m_menuImporter.isNull();
 }
 
-inline uint qHash(const QStringList &key, uint seed) {
-	uint hash(0);
-	for (const QString &s : key) {
-		hash ^= qHash(s, seed);
-	}
-	return hash;
-}
-
 void DBusMenuCollector::openMenu(QMenu *menu, unsigned int &limit) {
+	--limit;
+	if (limit == 0) {
+		QString error = "Hit DBusMenu safety valve opening menu at " + m_service
+				+ " " + m_path.path();
+		throw std::logic_error(error.toStdString());
+	}
+
 	if (!menu) {
 		return;
 	}
 
-	if (limit == 0) {
-		QString error = "Hit DBusMenu safety valve for menu at " + m_service
-				+ " " + m_path.path();
-		throw std::logic_error(error.toStdString());
-	}
-
 	menu->aboutToShow();
 
 	for (int i(0); m_menuImporter && i < menu->actions().size(); ++i) {
@@ -114,15 +107,15 @@
 
 		QMenu *child(action->menu());
 		if (child) {
-			--limit;
 			openMenu(child, limit);
 		}
 	}
 }
 
 void DBusMenuCollector::hideMenu(QMenu *menu, unsigned int &limit) {
+	--limit;
 	if (limit == 0) {
-		QString error = "Hit DBusMenu safety valve for menu at " + m_service
+		QString error = "Hit DBusMenu safety valve closing menu at " + m_service
 				+ " " + m_path.path();
 		throw std::logic_error(error.toStdString());
 	}
@@ -131,7 +124,6 @@
 		QAction *action = menu->actions().at(i);
 		QMenu *child(action->menu());
 		if (child) {
-			--limit;
 			hideMenu(child, limit);
 		}
 	}
 
=== modified file 'service/HudServiceImpl.cpp'
--- service/HudServiceImpl.cpp	2014-02-18 13:35:12 +0000
+++ service/HudServiceImpl.cpp	2014-06-13 07:41:53 +0000
@@ -104,13 +104,24 @@
 		QList<Suggestion> &suggestions, QDBusVariant &querykey) {
 	QString sender(messageSender());
 
-	Query::Ptr query(m_legacyQueries[sender]);
+	QPair<Query::Ptr, QSharedPointer<QTimer>> entry(m_legacyQueries[sender]);
+	Query::Ptr query(entry.first);
+	QSharedPointer<QTimer> legacyTimeout(entry.second);
 	if (query.isNull()) {
 		query = createQuery(queryString, sender,
 				Query::EmptyBehaviour::NO_SUGGESTIONS);
-		m_legacyQueries[sender] = query;
+
+		legacyTimeout.reset(new QTimer());
+		legacyTimeout->setInterval(2000);
+		legacyTimeout->setSingleShot(true);
+		connect(legacyTimeout.data(), SIGNAL(timeout()), this,
+				SLOT(legacyTimeout()));
+
+		m_legacyQueries[sender] = qMakePair(query, legacyTimeout);
 	} else {
 		query->UpdateQuery(queryString);
+		legacyTimeout->stop();
+		legacyTimeout->setProperty("sender", QVariant());
 	}
 
 	// The legacy API only allows you to search the current application
@@ -142,8 +153,13 @@
 	Q_UNUSED(timestamp);
 	QString sender(messageSender());
 
-	Query::Ptr query(m_legacyQueries.take(sender));
+	QPair<Query::Ptr, QSharedPointer<QTimer>> entry(m_legacyQueries.take(sender));
+	Query::Ptr query(entry.first);
+	QSharedPointer<QTimer> legacyTimeout(entry.second);
 	if (!query.isNull()) {
+		legacyTimeout->stop();
+		legacyTimeout->setProperty("sender", QVariant());
+
 		query->ExecuteCommand(itemKey, timestamp);
 		closeQuery(query->path());
 	}
@@ -156,8 +172,32 @@
 	// We don't actually close legacy queries, or we'd be constructing
 	// and destructing them during the search, due to the way that
 	// Unity7 uses the API.
-	Query::Ptr query(m_legacyQueries[sender]);
+	QPair<Query::Ptr, QSharedPointer<QTimer>> entry(m_legacyQueries[sender]);
+	Query::Ptr query(entry.first);
+	QSharedPointer<QTimer> legacyTimeout(entry.second);
 	if (!query.isNull()) {
 		query->UpdateQuery(QString());
-	}
+		legacyTimeout->start();
+		legacyTimeout->setProperty("sender", sender);
+	}
+}
+
+void HudServiceImpl::legacyTimeout() {
+	QObject *timer(sender());
+	if (!timer) {
+		return;
+	}
+
+	QVariant from(timer->property("sender"));
+	if (from.isNull()) {
+		return;
+	}
+
+	QString sender(from.toString());
+	QPair<Query::Ptr, QSharedPointer<QTimer>> entry(m_legacyQueries.take(sender));
+	Query::Ptr query(entry.first);
+	if (query) {
+		closeQuery(query->path());
+	}
+
 }
 
=== modified file 'service/HudServiceImpl.h'
--- service/HudServiceImpl.h	2014-02-18 13:35:12 +0000
+++ service/HudServiceImpl.h	2014-06-13 07:41:53 +0000
@@ -28,6 +28,7 @@
 #include <QDBusVariant>
 #include <QMap>
 #include <QScopedPointer>
+#include <QTimer>
 
 class HudAdaptor;
 
@@ -73,6 +74,9 @@
 
 	void CloseQuery(const QDBusVariant &querykey);
 
+protected Q_SLOTS:
+	void legacyTimeout();
+
 protected:
 	Query::Ptr createQuery(const QString &query, const QString &service,
 			Query::EmptyBehaviour emptyBehaviour);
@@ -85,7 +89,7 @@
 
 	QMap<QDBusObjectPath, Query::Ptr> m_queries;
 
-	QMap<QString, Query::Ptr> m_legacyQueries;
+	QMap<QString, QPair<Query::Ptr, QSharedPointer<QTimer>>> m_legacyQueries;
 
 	QSharedPointer<ApplicationList> m_applicationList;
 
 
=== modified file 'tests/unit/qtgmenu/TestQtGMenu.cpp'
--- tests/unit/qtgmenu/TestQtGMenu.cpp	2014-03-20 06:46:57 +0000
+++ tests/unit/qtgmenu/TestQtGMenu.cpp	2014-06-13 07:41:53 +0000
@@ -71,28 +71,28 @@
 
   int GetGMenuSize()
   {
-    GMenuModel* menu = m_importer.GetGMenuModel();
+    QSharedPointer<GMenuModel> menu = m_importer.GetGMenuModel();
 
     if( !menu )
     {
       return 0;
     }
 
-    gint item_count = g_menu_model_get_n_items( G_MENU_MODEL( menu ) );
+    gint item_count = g_menu_model_get_n_items( G_MENU_MODEL( menu.data() ) );
 
     return item_count;
   }
 
   int GetGActionCount()
   {
-    GActionGroup* actions = m_importer.GetGActionGroup();
+    QSharedPointer<GActionGroup> actions = m_importer.GetGActionGroup();
 
     if( !actions )
     {
       return 0;
     }
 
-    gchar** actions_list = g_action_group_list_actions( actions );
+    gchar** actions_list = g_action_group_list_actions( actions.data() );
 
     int action_count = 0;
     while( actions_list[action_count] != nullptr )