Merge lp:~3v1n0/unity/gnome-keygrabber-refactor into lp:unity

[Marco Trevisan (Treviño)]

GnomeKeyGrabber: Don't allow an action to be grabbed multiple times

And always return the same action id for a specific key binding.

1) Simplify Gnome key grabber actions allocation
2) Don't grab an action multiple times (at compiz level)
3) Only emit signals to the component that has requested the grab (and remove these on vanished)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4019
http://jenkins.qa.ubuntu.com/job/unity-ci/1304/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/82/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/80/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/80/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4021
http://jenkins.qa.ubuntu.com/job/unity-ci/1305/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/83/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/81/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/81/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4024
http://jenkins.qa.ubuntu.com/job/unity-ci/1306/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/84/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/82/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/82/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4025
http://jenkins.qa.ubuntu.com/job/unity-ci/1307/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/85/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/83/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/83/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4026
http://jenkins.qa.ubuntu.com/job/unity-ci/1308/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/86/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/84/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/84/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4027
http://jenkins.qa.ubuntu.com/job/unity-ci/1309/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/87/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/85
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/85/console

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

review: Needs Fixing (continuous-integration)

[Andrea Azzarone (azzar1)]

LGTM. Please next time avoid to changes thing that don't need to be changed (LoaderIcon...).

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4029
http://jenkins.qa.ubuntu.com/job/unity-ci/1310/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/88/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/86/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/86/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4032
http://jenkins.qa.ubuntu.com/job/unity-ci/1311/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/89
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/87
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/87/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:4033
http://jenkins.qa.ubuntu.com/job/unity-ci/1312/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/90
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/88
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/88/console

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-19 15:03:58 +0000
+++ CMakeLists.txt	2015-10-01 03:52:29 +0000
@@ -15,8 +15,8 @@
 set (UNITY_API_VERSION "6.0")
 set (UNITY_COMPONENTS_VERSION "6")
 
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGNOME_DESKTOP_USE_UNSTABLE_API -std=c++0x -fno-permissive")
-set (CMAKE_CXX_FLAGS_DEBUG "-g3")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGNOME_DESKTOP_USE_UNSTABLE_API -std=c++11 -fno-permissive")
+set (CMAKE_CXX_FLAGS_DEBUG "-g3 -DUNITY_DEBUG_BUILD")
 set (CMAKE_CXX_FLAGS_RELEASE "")
 
 option(

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2014-12-19 16:37:49 +0000
+++ UnityCore/CMakeLists.txt	2015-10-01 03:52:29 +0000
@@ -25,6 +25,7 @@
      Filter.h
      Filters.h
      GenericPreview.h
+     GLibDBusNameWatcher.h
      GLibDBusProxy.h
      GLibDBusServer.h
      GLibSignal.h
@@ -80,6 +81,7 @@
      Filter.cpp
      Filters.cpp
      GenericPreview.cpp
+     GLibDBusNameWatcher.cpp
      GLibDBusProxy.cpp
      GLibDBusServer.cpp
      GLibSignal.cpp

=== added file 'UnityCore/GLibDBusNameWatcher.cpp'
--- UnityCore/GLibDBusNameWatcher.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/GLibDBusNameWatcher.cpp	2015-10-01 03:52:29 +0000
@@ -0,0 +1,44 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include "GLibDBusNameWatcher.h"
+#include "GLibWrapper.h"
+
+namespace unity
+{
+namespace glib
+{
+
+DBusNameWatcher::DBusNameWatcher(std::string const& name, GBusType bus_type, GBusNameWatcherFlags flags)
+  : watcher_id_(g_bus_watch_name(bus_type, name.c_str(), flags,
+      [] (GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer self) {
+        static_cast<DBusNameWatcher*>(self)->appeared.emit(gchar_to_string(name), gchar_to_string(name_owner));
+      },
+      [] (GDBusConnection *connection, const gchar *name, gpointer self) {
+        static_cast<DBusNameWatcher*>(self)->vanished.emit(gchar_to_string(name));
+      }, this, nullptr))
+{}
+
+DBusNameWatcher::~DBusNameWatcher()
+{
+  g_bus_unwatch_name(watcher_id_);
+}
+
+} // namespace glib
+} // namespace unity

=== added file 'UnityCore/GLibDBusNameWatcher.h'
--- UnityCore/GLibDBusNameWatcher.h	1970-01-01 00:00:00 +0000
+++ UnityCore/GLibDBusNameWatcher.h	2015-10-01 03:52:29 +0000
@@ -0,0 +1,54 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef UNITY_GLIB_DBUS_NAME_WATCHER_H
+#define UNITY_GLIB_DBUS_NAME_WATCHER_H
+
+#include <gio/gio.h>
+#include <memory>
+#include <sigc++/signal.h>
+
+namespace unity
+{
+namespace glib
+{
+
+class DBusNameWatcher
+{
+public:
+  typedef std::shared_ptr<DBusNameWatcher> Ptr;
+
+  DBusNameWatcher(std::string const& name, GBusType bus_type = G_BUS_TYPE_SESSION, GBusNameWatcherFlags flags = G_BUS_NAME_WATCHER_FLAGS_NONE);
+  virtual ~DBusNameWatcher();
+
+  sigc::signal<void, std::string const& /* name*/, std::string const& /* name owner*/> appeared;
+  sigc::signal<void, std::string const& /* name */> vanished;
+
+private:
+  // not copyable class
+  DBusNameWatcher(DBusNameWatcher const&) = delete;
+  DBusNameWatcher& operator=(DBusNameWatcher const&) = delete;
+
+  uint32_t watcher_id_;
+};
+
+} // namespace glib
+} // namespace unity
+
+#endif //UNITY_GLIB_DBUS_NAME_WATCHER_H

=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2015-05-19 18:21:31 +0000
+++ UnityCore/GLibDBusProxy.cpp	2015-10-01 03:52:29 +0000
@@ -344,7 +344,8 @@
     // wait for the signal
     *con = proxy_acquired.connect([con, canc, timeout, callback] ()
     {
-      if (!g_cancellable_is_cancelled(canc)) callback(glib::Error());
+      if (!g_cancellable_is_cancelled(canc))
+        callback(glib::Error());
 
       timeout->Remove();
       con->disconnect();
@@ -390,12 +391,15 @@
   if (!proxy_)
   {
     glib::Variant sinked_parameters(parameters);
-    glib::Object<GCancellable>canc(target_canc, glib::AddRef());
+    glib::Object<GCancellable> canc(target_canc, glib::AddRef());
+
     WaitForProxy(canc, timeout_msec, [this, method_name, sinked_parameters, callback, canc, flags, timeout_msec] (glib::Error const& err)
     {
       if (err)
       {
-        callback(glib::Variant(), err);
+        if (callback)
+          callback(glib::Variant(), err);
+
         LOG_WARNING(logger) << "Cannot call method " << method_name
                             << ": " << err;
       }

=== modified file 'UnityCore/GLibDBusServer.cpp'
--- UnityCore/GLibDBusServer.cpp	2015-02-03 09:46:48 +0000
+++ UnityCore/GLibDBusServer.cpp	2015-10-01 03:52:29 +0000
@@ -87,7 +87,7 @@
 
       if (self->method_cb_)
       {
-        ret = self->method_cb_(method_name ? method_name : "", parameters);
+        ret = self->method_cb_(gchar_to_string(method_name), parameters, gchar_to_string(sender), gchar_to_string(object_path));
 
         LOG_INFO(logger_o) << "Called method: '" << method_name << " " << parameters
                            << "' on object '" << object_path << "' with interface '"
@@ -295,13 +295,14 @@
 
   void EmitGenericSignal(glib::Object<GDBusConnection> const& conn, std::string const& path,
                          std::string const& interface, std::string const& signal,
-                         GVariant* parameters = nullptr)
+                         GVariant* parameters = nullptr, std::string const& dest = "")
   {
     LOG_INFO(logger_o) << "Emitting signal '" << signal << "'" << " for the interface "
                      << "'" << interface << "' on object path '" << path << "'";
 
     glib::Error error;
-    g_dbus_connection_emit_signal(conn, nullptr, path.c_str(), interface.c_str(),
+    g_dbus_connection_emit_signal(conn, dest.empty() ? nullptr : dest.c_str(),
+                                  path.c_str(), interface.c_str(),
                                   signal.c_str(), parameters, &error);
 
     if (error)
@@ -312,7 +313,7 @@
     }
   }
 
-  void EmitSignal(std::string const& signal, GVariant* parameters, std::string const& path)
+  void EmitSignal(std::string const& signal, GVariant* parameters, std::string const& dest, std::string const& path)
   {
     glib::Variant reffed_params(parameters);
 
@@ -333,7 +334,7 @@
         return;
       }
 
-      EmitGenericSignal(conn_it->second, path, InterfaceName(), signal, parameters);
+      EmitGenericSignal(conn_it->second, path, InterfaceName(), signal, parameters, dest);
     }
     else
     {
@@ -343,7 +344,7 @@
         auto const& obj_path = pair.first;
         auto const& conn = pair.second;
 
-        EmitGenericSignal(conn, obj_path, InterfaceName(), signal, params);
+        EmitGenericSignal(conn, obj_path, InterfaceName(), signal, params, dest);
       }
     }
   }
@@ -401,7 +402,7 @@
   }
 
   DBusObject* object_;
-  MethodCallback method_cb_;
+  MethodCallbackFull method_cb_;
   PropertyGetterCallback property_get_cb_;
   PropertySetterCallback property_set_cb_;
 
@@ -420,6 +421,18 @@
 
 void DBusObject::SetMethodsCallsHandler(MethodCallback const& func)
 {
+  impl_->method_cb_ = nullptr;
+
+  if (func)
+  {
+    impl_->method_cb_ = [func] (std::string const& method, GVariant* parameters, std::string const&, std::string const&) {
+      return func(method, parameters);
+    };
+  }
+}
+
+void DBusObject::SetMethodsCallsHandlerFull(MethodCallbackFull const& func)
+{
   impl_->method_cb_ = func;
 }
 
@@ -448,9 +461,9 @@
   impl_->UnRegister(path);
 }
 
-void DBusObject::EmitSignal(std::string const& signal, GVariant* parameters, std::string const& path)
+void DBusObject::EmitSignal(std::string const& signal, GVariant* parameters, std::string const& dest, std::string const& path)
 {
-  impl_->EmitSignal(signal, parameters, path);
+  impl_->EmitSignal(signal, parameters, dest, path);
 }
 
 void DBusObject::EmitPropertyChanged(std::string const& property, std::string const& path)
@@ -648,12 +661,10 @@
     return DBusObject::Ptr();
   }
 
-  void EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters)
+  void EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters, std::string const& dest)
   {
-    auto const& obj = GetObject(interface);
-
-    if (obj)
-      obj->EmitSignal(signal, parameters);
+    if (DBusObject::Ptr const& obj = GetObject(interface))
+      obj->EmitSignal(signal, parameters, dest);
   }
 
   DBusServer* server_;
@@ -735,9 +746,9 @@
   return impl_->GetObject(interface);
 }
 
-void DBusServer::EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters)
+void DBusServer::EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters, std::string const& dest)
 {
-  impl_->EmitSignal(interface, signal, parameters);
+  impl_->EmitSignal(interface, signal, parameters, dest);
 }
 
 } // namespace glib

=== modified file 'UnityCore/GLibDBusServer.h'
--- UnityCore/GLibDBusServer.h	2014-04-09 13:19:33 +0000
+++ UnityCore/GLibDBusServer.h	2015-10-01 03:52:29 +0000
@@ -40,11 +40,13 @@
   DBusObject(std::string const& introspection_xml, std::string const& interface_name);
   virtual ~DBusObject();
 
-  typedef std::function<GVariant*(std::string const&, GVariant*)> MethodCallback;
-  typedef std::function<GVariant*(std::string const&)> PropertyGetterCallback;
-  typedef std::function<bool(std::string const&, GVariant*)> PropertySetterCallback;
+  typedef std::function<GVariant*(std::string const& /*method*/, GVariant* /*parameters*/)> MethodCallback;
+  typedef std::function<GVariant*(std::string const& /*method*/, GVariant* /*parameters*/, std::string const& /*sender*/, std::string const& /*object_path*/)> MethodCallbackFull;
+  typedef std::function<GVariant*(std::string const& /*name*/)> PropertyGetterCallback;
+  typedef std::function<bool(std::string const& /*name*/, GVariant* /*value*/)> PropertySetterCallback;
 
   void SetMethodsCallsHandler(MethodCallback const&);
+  void SetMethodsCallsHandlerFull(MethodCallbackFull const&);
   void SetPropertyGetter(PropertyGetterCallback const&);
   void SetPropertySetter(PropertySetterCallback const&);
 
@@ -53,7 +55,7 @@
   bool Register(glib::Object<GDBusConnection> const&, std::string const& path);
   void UnRegister(std::string const& path = "");
 
-  void EmitSignal(std::string const& signal, GVariant* parameters = nullptr, std::string const& path = "");
+  void EmitSignal(std::string const& signal, GVariant* parameters = nullptr, std::string const& dest = "", std::string const& path = "");
   void EmitPropertyChanged(std::string const& property, std::string const& path = "");
 
   sigc::signal<void, std::string const&> registered;
@@ -91,7 +93,7 @@
   std::list<DBusObject::Ptr> GetObjects() const;
   DBusObject::Ptr GetObject(std::string const& interface) const;
 
-  void EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters = nullptr);
+  void EmitSignal(std::string const& interface, std::string const& signal, GVariant* parameters = nullptr, std::string const& dest = "");
 
   bool IsConnected() const;
   std::string const& Name() const;

=== modified file 'panel/StandalonePanel.cpp'
--- panel/StandalonePanel.cpp	2014-02-17 20:15:02 +0000
+++ panel/StandalonePanel.cpp	2015-10-01 03:52:29 +0000
@@ -63,12 +63,10 @@
 
   struct MockKeyGrabber : key::Grabber
   {
-    CompAction::Vector& GetActions() { return actions_; }
-    void AddAction(CompAction const&) {}
-    void RemoveAction(CompAction const&) {}
-
-    private:
-      CompAction::Vector actions_;
+    CompAction::Vector& GetActions() override { return noActions(); }
+    uint32_t AddAction(CompAction const&) override { return 0; };
+    bool RemoveAction(CompAction const&) override { return false; };
+    bool RemoveAction(uint32_t id) override { return false; };
   };
 
   void Init()

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-09-08 02:19:56 +0000
+++ tests/CMakeLists.txt	2015-10-01 03:52:29 +0000
@@ -355,7 +355,7 @@
 endif (ENABLE_X_SUPPORT)
 set (GTEST_TEST_COMMAND_XLESS ./test-gtest-xless --gtest_output=xml:./test-gtest-xless.xml)
 set (GTEST_TEST_COMMAND_SLOW ./test-gtest-slow --gtest_output=xml:./test-gtest-slow.xml)
-set (GTEST_TEST_COMMAND_DBUS dbus-test-runner --max-wait=300 --task ./test-gtest-service --task-name test-service --task=./test-gtest-dbus --task-name=test-dbus --wait-for=com.canonical.Unity.Test.Scope --parameter=--gtest_output=xml:./test-gtest-dbus.xml --parameter=--gtest_filter=-TestCategoriesChanging*)
+set (GTEST_TEST_COMMAND_DBUS dbus-test-runner --max-wait=300 --task ./test-gtest-service --task-name test-service --task=./test-gtest-dbus --task-name=test-gtest-dbus --wait-for=com.canonical.Unity.Test --parameter=--gtest_output=xml:./test-gtest-dbus.xml --parameter=--gtest_filter=-TestCategoriesChanging*)
 
 set (TEST_COMMAND_XLESS
      ${GTEST_TEST_COMMAND_XLESS}

=== modified file 'tests/autopilot/unity/tests/test_gnome_key_grabber.py'
--- tests/autopilot/unity/tests/test_gnome_key_grabber.py	2015-03-24 13:58:12 +0000
+++ tests/autopilot/unity/tests/test_gnome_key_grabber.py	2015-10-01 03:52:29 +0000
@@ -154,20 +154,12 @@
 
         self.addCleanup(clean_up_test_grab_same_accelerator)
 
-        for accelerator in accelerators:
-            # Check that accelerator works
-            self.assertTrue(self.press_accelerator(accelerator))
-
-            # Remove accelerator
-            log.info('ungrabbing %s' % accelerator)
-            self.assertTrue(self.interface.UngrabAccelerator(accelerator.action))
-
-            # This accelerator cannot activate any more
-            self.activatable.remove(accelerator.action)
-
-        # Add them all again for one final check
-        for accelerator in accelerators:
-            self.activatable.add(accelerator.action)
-
-        # Check that signal was not emitted
-        self.assertFalse(self.press_accelerator(accelerators[0]))
+        # Check that accelerator works
+        self.assertTrue(self.press_accelerator(accelerator))
+
+        # Remove accelerator
+        log.info('ungrabbing %s' % accelerator)
+        self.assertTrue(self.interface.UngrabAccelerator(accelerator.action))
+
+        for accelerator in accelerators[1:]:
+            self.assertFalse(self.press_accelerator(accelerator))

=== modified file 'tests/mock_key_grabber.h'
--- tests/mock_key_grabber.h	2014-02-12 07:13:01 +0000
+++ tests/mock_key_grabber.h	2015-10-01 03:52:29 +0000
@@ -39,8 +39,9 @@
   }
 
   MOCK_METHOD0(GetActions, CompAction::Vector&());
-  MOCK_METHOD1(AddAction, void(CompAction const&));
-  MOCK_METHOD1(RemoveAction, void(CompAction const&));
+  MOCK_METHOD1(AddAction, uint32_t(CompAction const&));
+  MOCK_METHOD1(RemoveAction, bool(CompAction const&));
+  MOCK_METHOD1(RemoveAction, bool(uint32_t));
 
   CompAction::Vector actions_;
 };

=== modified file 'tests/test_glib_dbus_proxy.cpp'
--- tests/test_glib_dbus_proxy.cpp	2013-04-08 14:18:46 +0000
+++ tests/test_glib_dbus_proxy.cpp	2015-10-01 03:52:29 +0000
@@ -88,73 +88,85 @@
 
   Utils::WaitUntilMSec(got_result_return);
   Utils::WaitUntilMSec(got_signal_return);
- 
+
   EXPECT_EQ(returned_result, expected_return);
   EXPECT_EQ(returned_signal, expected_return);
 }
 
-TEST_F(TestGDBusProxy, TestCancelling)
-{
-  std::string call_return;
-  // method callback
-  auto method_connection = [&](GVariant *variant)
-  {
-    if (variant != nullptr)
-    {
-      call_return = g_variant_get_string(g_variant_get_child_value(variant, 0), NULL);
-    }
-
+TEST_F(TestGDBusProxy, TestCancellingBeforeConnecting)
+{
+  // method callback
+  auto method_connection = [this](GVariant *variant, glib::Error const& e)
+  {
+    got_result_return = true;
+  };
+
+  Utils::WaitUntilMSec(sigc::mem_fun(proxy, &glib::DBusProxy::IsConnected));
+
+  glib::Cancellable cancellable;
+  proxy.CallBegin("TestMethod", g_variant_new("(s)", "TestStringTestString"),
+                  method_connection, cancellable);
+
+  cancellable.Cancel();
+
+  Utils::WaitPendingEvents();
+  EXPECT_FALSE(got_result_return);
+}
+
+TEST_F(TestGDBusProxy, TestCancellingAfterConnecting)
+{
+  // method callback
+  auto method_connection = [this](GVariant *variant, glib::Error const& e)
+  {
     got_result_return = true;
   };
 
   EXPECT_FALSE(proxy.IsConnected()); // we shouldn't be connected yet
+
   glib::Cancellable cancellable;
-  // but this has to work eitherway
-  proxy.Call("TestMethod", g_variant_new("(s)", "TestStringTestString"),
-             method_connection, cancellable);
+  proxy.CallBegin("TestMethod", g_variant_new("(s)", "TestStringTestString"),
+                  method_connection, cancellable);
 
-  // this could mostly cause the next test to fail
+  Utils::WaitUntilMSec(sigc::mem_fun(proxy, &glib::DBusProxy::IsConnected));
   cancellable.Cancel();
+
+  Utils::WaitPendingEvents();
   EXPECT_FALSE(got_result_return);
 }
 
-TEST_F(TestGDBusProxy, TestAcquiring)
+TEST_F(TestGDBusProxy, TestMultipleCalls)
 {
   const int NUM_REQUESTS = 10;
   int completed = 0;
   std::string call_return;
   // method callback
-  auto method_connection = [&](GVariant* variant, glib::Error const& err)
+  auto method_connection = [&](GVariant* variant)
   {
-    if (variant != nullptr)
-    {
-      call_return = g_variant_get_string(g_variant_get_child_value(variant, 0), NULL);
-    }
-
     if (++completed >= NUM_REQUESTS) got_result_return = true;
   };
 
   EXPECT_FALSE(proxy.IsConnected()); // we shouldn't be connected yet
   for (int i = 0; i < NUM_REQUESTS; i++)
-  {
-    proxy.CallBegin("TestMethod", g_variant_new("(s)", "TestStringTestString"),
-                    method_connection, nullptr);
-    Utils::WaitForTimeoutMSec(150);
-  }
-  Utils::WaitUntilMSec(got_result_return, 2);
+    proxy.Call("TestMethod", g_variant_new("(s)", "TestStringTestString"), method_connection, nullptr);
+
+  Utils::WaitPendingEvents();
+  Utils::WaitUntilMSec(got_result_return, 150, G_STRLOC);
+  EXPECT_EQ(completed, NUM_REQUESTS);
 }
 
 TEST_F(TestGDBusProxyInvalidService, TestTimeouting)
 {
   std::string call_return;
+  bool error;
   // method callback
-  auto method_connection = [&](GVariant* variant, glib::Error const& err)
+  auto method_connection = [&](GVariant* variant, glib::Error const& e)
   {
     if (variant != nullptr)
     {
       call_return = g_variant_get_string(g_variant_get_child_value(variant, 0), NULL);
     }
 
+    error = e;
     got_result_return = true;
   };
 
@@ -168,6 +180,7 @@
 
   Utils::WaitUntilMSec(got_result_return);
   EXPECT_EQ(call_return, "");
+  EXPECT_TRUE(error);
 }
 
 TEST_F(TestGDBusProxy, TestMethodCall)
@@ -190,7 +203,7 @@
              method_connection);
 
   Utils::WaitUntilMSec(got_result_return);
- 
+
   EXPECT_TRUE(proxy.IsConnected());
   EXPECT_EQ("TestStringTestString", call_return);
 }

=== modified file 'tests/test_gnome_session_manager.cpp'
--- tests/test_gnome_session_manager.cpp	2015-09-08 01:54:55 +0000
+++ tests/test_gnome_session_manager.cpp	2015-10-01 03:52:29 +0000
@@ -1090,7 +1090,7 @@
   EXPECT_TRUE(unlock_emitted);
 }
 
-TEST_F(TestGnomeSessionManager, NoLockWhenLockingDisabled)
+TEST_F(TestGnomeSessionManager, UNSTABLE_TEST(NoLockWhenLockingDisabled))
 {
   bool lock_emitted = false;
   bool screensaver_emitted = false;

=== modified file 'tests/test_icon_loader.cpp'
--- tests/test_icon_loader.cpp	2014-07-30 00:49:35 +0000
+++ tests/test_icon_loader.cpp	2015-10-01 03:52:29 +0000
@@ -53,6 +53,7 @@
 
 void CheckResults(std::vector<LoadResult> const& results)
 {
+  Utils::WaitPendingEvents(WAIT_TIMEOUT);
   Utils::WaitUntilMSec([&results] {
     bool got_all = true;
     for (auto const& result : results)
@@ -101,8 +102,7 @@
   EXPECT_EQ(&icon_loader, &IconLoader::GetDefault());
 }
 
-// FIXME: Disabled due to issues on Jenkins using GLibDBusProxy (lp:1224643)
-TEST_F(TestIconLoader, DISABLED_TestGetOneIcon)
+TEST_F(TestIconLoader, UNSTABLE_TEST(TestGetOneIcon))
 {
   LoadResult load_result;
 
@@ -110,13 +110,13 @@
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
+  Utils::WaitPendingEvents(WAIT_TIMEOUT);
   Utils::WaitUntilMSec(load_result.got_callback, WAIT_TIMEOUT);
   EXPECT_TRUE(load_result.got_callback);
   EXPECT_TRUE(IsValidPixbuf(load_result.pixbuf));
 }
 
-// FIXME: Disabled due to issues on Jenkins using GLibDBusProxy (lp:1224643)
-TEST_F(TestIconLoader, DISABLED_TestGetAnnotatedIcon)
+TEST_F(TestIconLoader, UNSTABLE_TEST(TestGetAnnotatedIcon))
 {
   LoadResult load_result;
 
@@ -124,13 +124,13 @@
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
+  Utils::WaitPendingEvents(WAIT_TIMEOUT);
   Utils::WaitUntilMSec(load_result.got_callback, WAIT_TIMEOUT);
   EXPECT_TRUE(load_result.got_callback);
   EXPECT_TRUE(IsValidPixbuf(load_result.pixbuf));
 }
 
-// FIXME: Disabled due to issues on Jenkins using GLibDBusProxy (lp:1224643)
-TEST_F(TestIconLoader, DISABLED_TestGetColorizedIcon)
+TEST_F(TestIconLoader, UNSTABLE_TEST(TestGetColorizedIcon))
 {
   LoadResult load_result;
 
@@ -138,6 +138,7 @@
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
+  Utils::WaitPendingEvents(WAIT_TIMEOUT);
   Utils::WaitUntilMSec(load_result.got_callback, WAIT_TIMEOUT);
   EXPECT_TRUE(load_result.got_callback);
   EXPECT_TRUE(IsValidPixbuf(load_result.pixbuf));
@@ -173,8 +174,7 @@
   CheckResults(results);
 }
 
-// Disabled until we have the new thread safe lp:fontconfig
-TEST_F(TestIconLoader, DISABLED_TestGetManyIcons)
+TEST_F(TestIconLoader, TestGetManyIcons)
 {
   std::vector<LoadResult> results;
   int i = 0;

=== modified file 'tests/test_main_dbus.cpp'
--- tests/test_main_dbus.cpp	2013-04-08 14:07:26 +0000
+++ tests/test_main_dbus.cpp	2015-10-01 03:52:29 +0000
@@ -2,6 +2,7 @@
 #include <gio/gio.h>
 #include <NuxCore/Logger.h>
 #include <Nux/Nux.h>
+#include <UnityCore/GLibDBusNameWatcher.h>
 #include "test_utils.h"
 
 #include "config.h"
@@ -35,7 +36,7 @@
     g_print ("option parsing failed: %s\n", error->message);
     return 1;
   }
-  
+
   signal(SIGINT, signal_handler);
   nux::NuxInitialize (0);
 
@@ -66,24 +67,12 @@
 static bool wait_until_test_service_appears()
 {
   bool have_name = false;
-
-  auto callback = [](GDBusConnection * conn,
-                     const char * name,
-                     const char * name_owner,
-                     gpointer user_data)
-  {
-    *(bool*)user_data = true;
-  };
-
-  g_bus_watch_name(G_BUS_TYPE_SESSION,
-                   "com.canonical.Unity.Test",
-                   G_BUS_NAME_WATCHER_FLAGS_NONE,
-                   callback,
-                   NULL,
-                   &have_name,
-                   NULL);
-
-  Utils::WaitUntil(have_name, 3);
+  unity::glib::DBusNameWatcher watcher("com.canonical.Unity.Test");
+  watcher.appeared.connect([&have_name] (std::string const&, std::string const&) {
+    have_name = true;
+  });
+
+  Utils::WaitUntil(have_name, 3, "Service has not appeared");
   EXPECT_TRUE(have_name);
 
   return have_name;
@@ -92,6 +81,12 @@
 static void tell_service_to_exit()
 {
   // Ask the service to exit
+  bool lost_name = false;
+  unity::glib::DBusNameWatcher watcher("com.canonical.Unity.Test");
+  watcher.vanished.connect([&lost_name] (std::string const&) {
+    lost_name = true;
+  });
+
   GDBusConnection* connection = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
   g_dbus_connection_call_sync(connection,
                               "com.canonical.Unity.Test",
@@ -104,6 +99,9 @@
                               -1,
                               NULL, NULL);
   g_object_unref(connection);
+
+  Utils::WaitUntil(lost_name, 3, "Service is not vanished");
+  EXPECT_TRUE(lost_name);
 }
 
 static void signal_handler(int sig)

=== modified file 'tests/test_result_renderer.cpp'
--- tests/test_result_renderer.cpp	2014-07-30 00:49:35 +0000
+++ tests/test_result_renderer.cpp	2015-10-01 03:52:29 +0000
@@ -79,7 +79,7 @@
   }
 
 private:
-  std::auto_ptr<dash::TextureContainer> renderer_;
+  std::unique_ptr<dash::TextureContainer> renderer_;
 };
 
 TEST_F(TestResultRenderer, TestConstruction)

=== modified file 'tests/test_service_panel.cpp'
--- tests/test_service_panel.cpp	2015-01-14 22:50:25 +0000
+++ tests/test_service_panel.cpp	2015-10-01 03:52:29 +0000
@@ -17,6 +17,10 @@
 "      <arg type='" ENTRY_ARRAY_SIGNATURE "' name='state' direction='out'/>"
 "    </method>"
 "\n"
+"    <method name='GetIconPaths'>"
+"      <arg type='as' name='paths' direction='out'/>"
+"    </method>"
+"\n"
 "    <signal name='ReSync'>"
 "     <arg type='s' name='indicator_id' />"
 "    </signal>"
@@ -118,6 +122,10 @@
   {
     return g_variant_new("(b)", trigger_resync1_sent_ ? TRUE : FALSE);
   }
+  else if (method == "GetIconPaths")
+  {
+    return g_variant_new("(as)", nullptr);
+  }
 
   return nullptr;
 }

=== modified file 'tests/test_showdesktop_handler.cpp'
--- tests/test_showdesktop_handler.cpp	2013-07-23 12:28:01 +0000
+++ tests/test_showdesktop_handler.cpp	2015-10-01 03:52:29 +0000
@@ -3,6 +3,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <UnityShowdesktopHandler.h>
+#include "test_utils.h"
 
 using namespace unity;
 using ::testing::_;
@@ -404,7 +405,7 @@
   EXPECT_EQ (ShowdesktopHandler::animating_windows.size (), 1);
 }
 
-TEST_F(UnityShowdesktopHandlerTest, DISABLED_TestAnimationOpacity)
+TEST_F(UnityShowdesktopHandlerTest, UNSTABLE_TEST(TestAnimationOpacity))
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 

=== modified file 'tests/test_utils.h'
--- tests/test_utils.h	2014-01-29 14:42:06 +0000
+++ tests/test_utils.h	2015-10-01 03:52:29 +0000
@@ -8,6 +8,16 @@
 #include "GLibWrapper.h"
 #include "config.h"
 
+#ifdef UNITY_DEBUG_BUILD
+#define UNSTABLE_PREFIX UNSTABLE
+#else
+#define UNSTABLE_PREFIX DISABLED
+#endif
+
+#define TEST_PREFIX(prefix,test) prefix ## _ ## test
+#define TEST_EVALUATOR(prefix,test) TEST_PREFIX(prefix,test)
+#define UNSTABLE_TEST(test) TEST_EVALUATOR(UNSTABLE_PREFIX, test)
+
 namespace
 {
 

=== modified file 'tests/test_xdnd_start_stop_notifier_imp.cpp'
--- tests/test_xdnd_start_stop_notifier_imp.cpp	2012-11-24 14:28:14 +0000
+++ tests/test_xdnd_start_stop_notifier_imp.cpp	2015-10-01 03:52:29 +0000
@@ -47,7 +47,7 @@
   unity::XdndStartStopNotifierImp xdnd_start_stop_notifier;
 };
 
-TEST_F(TestXdndStartStopNotifierImp, DISABLED_SignalStarted)
+TEST_F(TestXdndStartStopNotifierImp, UNSTABLE_TEST(SignalStarted))
 {
   bool signal_received = false;
   xdnd_start_stop_notifier.started.connect([&](){
@@ -63,7 +63,7 @@
   //XTestFakeButtonEvent(display_, 1, False, CurrentTime);
 }
 
-TEST_F(TestXdndStartStopNotifierImp, DISABLED_SignalFinished)
+TEST_F(TestXdndStartStopNotifierImp, UNSTABLE_TEST(SignalFinished))
 {
   bool signal_received = false;
   xdnd_start_stop_notifier.finished.connect([&](){

=== modified file 'unity-shared/GnomeKeyGrabber.cpp'
--- unity-shared/GnomeKeyGrabber.cpp	2015-03-18 15:04:38 +0000
+++ unity-shared/GnomeKeyGrabber.cpp	2015-10-01 03:52:29 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2013 Canonical Ltd
+ * 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 General Public License version 3 as
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: William Hua <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #include "GnomeKeyGrabberImpl.h"
@@ -63,168 +64,174 @@
 std::string const DBUS_NAME = "com.canonical.Unity.Test.GnomeKeyGrabber";
 }
 
+namespace
+{
+inline int compiz_event_timestamp(CompOption::Vector& options) { return options[7].value().i(); }
+}
+
 GnomeGrabber::Impl::Impl(bool test_mode)
-  : shell_server_(test_mode ? testing::DBUS_NAME : shell::DBUS_NAME)
-  , screen_(screen)
+  : screen_(screen)
+  , shell_server_(test_mode ? testing::DBUS_NAME : shell::DBUS_NAME)
   , current_action_id_(0)
 {
   shell_server_.AddObjects(shell::INTROSPECTION_XML, shell::DBUS_OBJECT_PATH);
   shell_object_ = shell_server_.GetObject(shell::DBUS_INTERFACE);
-  shell_object_->SetMethodsCallsHandler(sigc::mem_fun(this, &Impl::onShellMethodCall));
+  shell_object_->SetMethodsCallsHandlerFull(sigc::mem_fun(this, &Impl::OnShellMethodCall));
 }
 
 GnomeGrabber::Impl::~Impl()
 {
-  if (screen_)
-  {
-    for (auto& action : actions_)
-      screen_->removeAction(&action);
-  }
-}
-
-unsigned int GnomeGrabber::Impl::addAction(CompAction const& action, bool addressable)
-{
-  ++current_action_id_;
-  actions_.push_back(action);
-  action_ids_.push_back(current_action_id_);
-
-  if (addressable)
-  {
-    action_ids_by_action_[&action] = current_action_id_;
-    actions_by_action_id_[current_action_id_] = &action;
-  }
-
-  if (screen_)
-    screen_->addAction(&actions_.back());
-
-  LOG_DEBUG(logger) << "addAction (\"" << action.keyToString() << "\", " << addressable << ") = " << current_action_id_;
-
-  return current_action_id_;
-}
-
-bool GnomeGrabber::Impl::removeAction(CompAction const& action)
-{
-  auto i = action_ids_by_action_.find(&action);
-  return i != action_ids_by_action_.end() && removeAction(i->second);
-}
-
-bool GnomeGrabber::Impl::removeAction(unsigned int action_id)
-{
-  auto i = std::find(action_ids_.begin(), action_ids_.end(), action_id);
-
-  if (i != action_ids_.end())
-  {
-    auto j = actions_.begin() + (i - action_ids_.begin());
-    auto k = actions_by_action_id_.find(action_id);
-
-    LOG_DEBUG(logger) << "removeAction (" << action_id << " \"" << j->keyToString() << "\")";
-
-    if (screen_)
-      screen_->removeAction(&(*j));
-
-    if (k != actions_by_action_id_.end())
-    {
-      action_ids_by_action_.erase(k->second);
-      actions_by_action_id_.erase(k);
-    }
-
-    action_ids_.erase(i);
-    actions_.erase(j);
-    return true;
-  }
-
-  return false;
-}
-
-GVariant* GnomeGrabber::Impl::onShellMethodCall(std::string const& method, GVariant* parameters)
+  for (auto& action : actions_)
+    screen_->removeAction(&action);
+}
+
+uint32_t GnomeGrabber::Impl::NextActionID()
+{
+  return ++current_action_id_;
+}
+
+bool GnomeGrabber::Impl::AddAction(CompAction const& action, uint32_t& action_id)
+{
+  LOG_DEBUG(logger) << "AddAction (\"" << action.keyToString() << "\") = " << action_id;
+
+  if (action.key().toString().empty())
+  {
+    LOG_WARN(logger) << "Trying to grab a disabled action, we skip it";
+    return false;
+  }
+
+  auto it = std::find(actions_.begin(), actions_.end(), action);
+  if (it != actions_.end())
+  {
+    action_id = actions_ids_[it - actions_.begin()];
+    LOG_DEBUG(logger) << "Key binding \"" << action.keyToString() << "\" is already grabbed, reusing id " << action_id;
+    return true;
+  }
+
+  if (screen_->addAction(const_cast<CompAction*>(&action)))
+  {
+    actions_ids_.push_back(action_id);
+    actions_.push_back(action);
+    return true;
+  }
+
+  LOG_ERROR(logger) << "Impossible to grab action \"" << action.keyToString() << "\"";
+  return false;
+}
+
+uint32_t GnomeGrabber::Impl::AddAction(CompAction const& action)
+{
+  auto action_id = NextActionID();
+  return AddAction(action, action_id) ? action_id : 0;
+}
+
+bool GnomeGrabber::Impl::RemoveAction(CompAction const& action)
+{
+  auto it = std::find(actions_.begin(), actions_.end(), action);
+
+  if (it != actions_.end())
+    return RemoveActionByIndex(it - actions_.begin());
+
+  return false;
+}
+
+bool GnomeGrabber::Impl::RemoveActionByID(uint32_t action_id)
+{
+  if (!action_id)
+    return false;
+
+  auto it = std::find(actions_ids_.begin(), actions_ids_.end(), action_id);
+
+  if (it != actions_ids_.end())
+    return RemoveActionByIndex(it - actions_ids_.begin());
+
+  return false;
+}
+
+bool GnomeGrabber::Impl::RemoveActionByIndex(size_t index)
+{
+  if (!index || index >= actions_.size())
+    return false;
+
+  CompAction* action = &(actions_[index]);
+  LOG_DEBUG(logger) << "RemoveAction (\"" << action->keyToString() << "\")";
+
+  screen_->removeAction(action);
+  actions_.erase(actions_.begin() + index);
+  actions_ids_.erase(actions_ids_.begin() + index);
+
+  return true;
+}
+
+GVariant* GnomeGrabber::Impl::OnShellMethodCall(std::string const& method, GVariant* parameters, std::string const& sender, std::string const&)
 {
   LOG_DEBUG(logger) << "Called method '" << method << "'";
 
   if (method == "GrabAccelerators")
   {
-    if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(a(su))")))
-    {
-      GVariant* variant;
-      GVariantBuilder builder;
-      GVariantIter* iterator;
-      gchar const* accelerator;
-      guint flags;
-
-      g_variant_builder_init(&builder, G_VARIANT_TYPE("au"));
-      g_variant_get(parameters, "(a(su))", &iterator);
-
-      while (g_variant_iter_next(iterator, "(&su)", &accelerator, &flags))
-        g_variant_builder_add(&builder, "u", grabAccelerator(accelerator, flags));
-
-      g_variant_iter_free(iterator);
-      variant = g_variant_builder_end(&builder);
-      return g_variant_new_tuple(&variant, 1);
-    }
-    else
-      LOG_WARN(logger) << "Expected arguments of type (a(su))";
+    GVariant* variant;
+    GVariantBuilder builder;
+    GVariantIter* iterator;
+    gchar const* accelerator;
+    guint flags;
+
+    g_variant_builder_init(&builder, G_VARIANT_TYPE("au"));
+    g_variant_get(parameters, "(a(su))", &iterator);
+
+    while (g_variant_iter_next(iterator, "(&su)", &accelerator, &flags))
+      g_variant_builder_add(&builder, "u", GrabDBusAccelerator(sender, accelerator, flags));
+
+    g_variant_iter_free(iterator);
+    variant = g_variant_builder_end(&builder);
+    return g_variant_new_tuple(&variant, 1);
   }
   else if (method == "GrabAccelerator")
   {
-    if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(su)")))
-    {
-      GVariant* variant;
-      gchar const* accelerator;
-      guint flags;
+    gchar const* accelerator;
+    guint flags;
+    g_variant_get(parameters, "(&su)", &accelerator, &flags);
 
-      g_variant_get(parameters, "(&su)", &accelerator, &flags);
-      variant = g_variant_new_uint32(grabAccelerator(accelerator, flags));
-      return g_variant_new_tuple(&variant, 1);
-    }
-    else
-      LOG_WARN(logger) << "Expected arguments of type (su)";
+    if (uint32_t action_id = GrabDBusAccelerator(sender, accelerator, flags))
+      return g_variant_new("(u)", action_id);
   }
   else if (method == "UngrabAccelerator")
   {
-    if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(u)")))
-    {
-      GVariant* variant;
-      guint action;
-
-      g_variant_get(parameters, "(u)", &action);
-      variant = g_variant_new_boolean(removeAction(action));
-      return g_variant_new_tuple(&variant, 1);
-    }
-    else
-      LOG_WARN(logger) << "Expected arguments of type (u)";
+    uint32_t action_id;
+    g_variant_get(parameters, "(u)", &action_id);
+    return g_variant_new("(b)", UnGrabDBusAccelerator(sender, action_id));
   }
 
   return nullptr;
 }
 
-unsigned int GnomeGrabber::Impl::grabAccelerator(char const* accelerator, unsigned int flags)
+uint32_t GnomeGrabber::Impl::GrabDBusAccelerator(std::string const& owner, std::string const& accelerator, uint32_t flags)
 {
   CompAction action;
   action.keyFromString(accelerator);
+  uint32_t action_id = NextActionID();
+
+  LOG_DEBUG(logger) << "GrabDBusAccelerator \"" << accelerator << "\"";
 
   if (action.key().toString().empty())
   {
-    CompString prefixed = "XF86" + CompString(accelerator);
+    auto prefixed = "XF86" + accelerator;
     LOG_DEBUG(logger) << "Can't grab \"" << accelerator << "\", trying \"" << prefixed << "\"";
     action.keyFromString(prefixed);
   }
-  else
-  {
-    LOG_DEBUG(logger) << "grabAccelerator \"" << accelerator << "\"";
-  }
 
-  if (!isActionPostponed(action))
+  if (!IsActionPostponed(action))
   {
     action.setState(CompAction::StateInitKey);
-    action.setInitiate([this](CompAction* action, CompAction::State state, CompOption::Vector& options) {
+    action.setInitiate([this, action_id](CompAction* action, CompAction::State state, CompOption::Vector& options) {
       LOG_DEBUG(logger) << "pressed \"" << action->keyToString() << "\"";
-      activateAction(action, 0, options[7].value().i());
+      ActivateDBusAction(*action, action_id, 0, compiz_event_timestamp(options));
       return true;
     });
   }
   else
   {
     action.setState(CompAction::StateInitKey | CompAction::StateTermKey);
-    action.setTerminate([this](CompAction* action, CompAction::State state, CompOption::Vector& options) {
+    action.setTerminate([this, action_id](CompAction* action, CompAction::State state, CompOption::Vector& options) {
       auto key = action->keyToString();
 
       LOG_DEBUG(logger) << "released \"" << key << "\"";
@@ -232,7 +239,7 @@
       if (state & CompAction::StateTermTapped)
       {
         LOG_DEBUG(logger) << "tapped \"" << key << "\"";
-        activateAction(action, 0, options[7].value().i());
+        ActivateDBusAction(*action, action_id, 0, compiz_event_timestamp(options));
         return true;
       }
 
@@ -240,22 +247,86 @@
     });
   }
 
-  return addAction(action, false);
-}
-
-void GnomeGrabber::Impl::activateAction(CompAction const* action, unsigned device, unsigned timestamp) const
-{
-  ptrdiff_t i = action - &actions_.front();
-
-  if (0 <= i && i < static_cast<ptrdiff_t>(action_ids_.size()))
-  {
-    auto action_id = action_ids_[i];
-    LOG_DEBUG(logger) << "activateAction (" << action_id << " \"" << action->keyToString() << "\")";
-    shell_object_->EmitSignal("AcceleratorActivated", g_variant_new("(uuu)", action_id, device, timestamp));
-  }
-}
-
-bool GnomeGrabber::Impl::isActionPostponed(CompAction const& action) const
+  if (AddAction(action, action_id))
+  {
+    auto& owner_actions = actions_by_owner_[owner];
+    bool first_insertion = owner_actions.actions.empty();
+    owner_actions.actions.insert(action_id);
+
+    if (first_insertion)
+    {
+      LOG_DEBUG(logger) << "Initialize dbus watcher for owner '" << owner << "'";
+      owner_actions.watcher = std::make_shared<glib::DBusNameWatcher>(owner);
+      owner_actions.watcher->vanished.connect([this] (std::string const& name) {
+        LOG_DEBUG(logger) << "Signal destination vanished '" << name << "', removing related actions";
+        auto it = actions_by_owner_.find(name);
+        if (it != actions_by_owner_.end())
+        {
+          for (auto action_id : it->second.actions)
+            RemoveActionForOwner(action_id, name);
+
+          actions_by_owner_.erase(it);
+        }
+      });
+    }
+
+    return action_id;
+  }
+
+  return 0;
+}
+
+bool GnomeGrabber::Impl::UnGrabDBusAccelerator(std::string const& owner, uint32_t action_id)
+{
+  LOG_DEBUG(logger) << "UnGrabDBusAccelerator \"" << action_id << "\"";
+
+  auto it = actions_by_owner_.find(owner);
+  if (it != actions_by_owner_.end())
+  {
+    auto& actions = it->second.actions;
+    actions.erase(action_id);
+
+    if (actions.empty())
+      actions_by_owner_.erase(it);
+
+    return RemoveActionForOwner(action_id, owner);
+  }
+
+  LOG_WARN(logger) << "Action " << action_id << " was not registered by " << owner << ". "
+                   << "Unregistration denied";
+  return false;
+}
+
+bool GnomeGrabber::Impl::RemoveActionForOwner(uint32_t action_id, std::string const& owner)
+{
+  for (auto it = actions_by_owner_.begin(); it != actions_by_owner_.end(); ++it)
+  {
+    if (it->first == owner)
+      continue;
+
+    auto const& actions = it->second.actions;
+    if (actions.find(action_id) != actions.end())
+    {
+      LOG_DEBUG(logger) << "Action " << action_id << " registered for multiple destinations, not removed";
+      return false;
+    }
+  }
+
+  return RemoveActionByID(action_id);
+}
+
+void GnomeGrabber::Impl::ActivateDBusAction(CompAction const& action, uint32_t action_id, uint32_t device, uint32_t timestamp) const
+{
+  LOG_DEBUG(logger) << "ActivateAction (" << action_id << " \"" << action.keyToString() << "\")";
+
+  for (auto const& pair : actions_by_owner_)
+  {
+    if (pair.second.actions.find(action_id) != pair.second.actions.end())
+      shell_object_->EmitSignal("AcceleratorActivated", g_variant_new("(uuu)", action_id, device, timestamp), pair.first);
+  }
+}
+
+bool GnomeGrabber::Impl::IsActionPostponed(CompAction const& action) const
 {
   int keycode = action.key().keycode();
   return keycode == 0 || modHandler->keycodeToModifiers(keycode) != 0;
@@ -279,14 +350,19 @@
   return impl_->actions_;
 }
 
-void GnomeGrabber::AddAction(CompAction const& action)
-{
-  impl_->addAction(action);
-}
-
-void GnomeGrabber::RemoveAction(CompAction const& action)
-{
-  impl_->removeAction(action);
+uint32_t GnomeGrabber::AddAction(CompAction const& action)
+{
+  return impl_->AddAction(action);
+}
+
+bool GnomeGrabber::RemoveAction(CompAction const& action)
+{
+  return impl_->RemoveAction(action);
+}
+
+bool GnomeGrabber::RemoveAction(uint32_t action_id)
+{
+  return impl_->RemoveActionByID(action_id);
 }
 
 } // namespace key

=== modified file 'unity-shared/GnomeKeyGrabber.h'
--- unity-shared/GnomeKeyGrabber.h	2014-02-12 07:13:01 +0000
+++ unity-shared/GnomeKeyGrabber.h	2015-10-01 03:52:29 +0000
@@ -32,9 +32,11 @@
   GnomeGrabber();
   virtual ~GnomeGrabber();
 
-  void AddAction(CompAction const&);
-  void RemoveAction(CompAction const&);
-  CompAction::Vector& GetActions();
+  uint32_t AddAction(CompAction const&) override;
+  bool RemoveAction(CompAction const&) override;
+  bool RemoveAction(uint32_t action_id) override;
+
+  CompAction::Vector& GetActions() override;
 
 protected:
   struct TestMode {};

=== modified file 'unity-shared/GnomeKeyGrabberImpl.h'
--- unity-shared/GnomeKeyGrabberImpl.h	2015-03-18 15:04:38 +0000
+++ unity-shared/GnomeKeyGrabberImpl.h	2015-10-01 03:52:29 +0000
@@ -1,21 +1,22 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
-* Copyright (C) 2013 Canonical Ltd
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 3 as
-* published by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* Authored by: William Hua <[e-mail]>
-*/
+ * 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 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: William Hua <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
+ */
 
 #ifndef __GNOME_KEY_GRABBER_IMPL_H__
 #define __GNOME_KEY_GRABBER_IMPL_H__
@@ -23,8 +24,10 @@
 #include "GnomeKeyGrabber.h"
 
 #include <unordered_map>
+#include <unordered_set>
 #include <UnityCore/GLibDBusProxy.h>
 #include <UnityCore/GLibDBusServer.h>
+#include <UnityCore/GLibDBusNameWatcher.h>
 
 namespace unity
 {
@@ -36,26 +39,34 @@
   Impl(bool test_mode = false);
   ~Impl();
 
+  uint32_t NextActionID();
+
+  bool AddAction(CompAction const& action, uint32_t& action_id);
+  uint32_t AddAction(CompAction const& action);
+
+  bool RemoveAction(CompAction const& action);
+  bool RemoveActionByID(uint32_t action_id);
+  bool RemoveActionByIndex(size_t index);
+
+  GVariant* OnShellMethodCall(std::string const& method, GVariant* parameters, std::string const& sender, std::string const&);
+  uint32_t GrabDBusAccelerator(std::string const& owner, std::string const& accelerator, uint32_t flags);
+  bool UnGrabDBusAccelerator(std::string const& sender, uint32_t action_id);
+  void ActivateDBusAction(CompAction const& action, uint32_t id, uint32_t device, uint32_t timestamp) const;
+  bool RemoveActionForOwner(uint32_t action_id, std::string const& owner);
+
+  bool IsActionPostponed(CompAction const& action) const;
+
+  CompScreen* screen_;
+
   glib::DBusServer shell_server_;
   glib::DBusObject::Ptr shell_object_;
 
-  CompScreen* screen_;
+  uint32_t current_action_id_;
+  std::vector<uint32_t> actions_ids_;
   CompAction::Vector actions_;
-  std::vector<unsigned int> action_ids_;
-  unsigned int current_action_id_;
-
-  std::unordered_map<CompAction const*, unsigned int> action_ids_by_action_;
-  std::unordered_map<unsigned int, CompAction const*> actions_by_action_id_;
-
-  unsigned int addAction(CompAction const& action, bool addressable = true);
-  bool removeAction(CompAction const& action);
-  bool removeAction(unsigned int action_id);
-
-  GVariant* onShellMethodCall(std::string const& method, GVariant* parameters);
-  unsigned int grabAccelerator(char const* accelerator, unsigned int flags);
-  void activateAction(CompAction const* action, unsigned device, unsigned timestamp) const;
-
-  bool isActionPostponed(CompAction const& action) const;
+
+  struct OwnerActions { glib::DBusNameWatcher::Ptr watcher; std::unordered_set<uint32_t> actions; };
+  std::unordered_map<std::string, OwnerActions> actions_by_owner_;
 };
 
 } // namespace key

=== modified file 'unity-shared/KeyGrabber.h'
--- unity-shared/KeyGrabber.h	2014-02-12 07:13:01 +0000
+++ unity-shared/KeyGrabber.h	2015-10-01 03:52:29 +0000
@@ -32,8 +32,10 @@
   typedef std::shared_ptr<Grabber> Ptr;
   virtual ~Grabber() = default;
 
-  virtual void AddAction(CompAction const&) = 0;
-  virtual void RemoveAction(CompAction const&) = 0;
+  virtual uint32_t AddAction(CompAction const&) = 0;
+  virtual bool RemoveAction(CompAction const&) = 0;
+  virtual bool RemoveAction(uint32_t id) = 0;
+
   virtual CompAction::Vector& GetActions() = 0;
 };
 

=== modified file 'unity-shared/MenuManager.cpp'
--- unity-shared/MenuManager.cpp	2015-09-17 16:44:26 +0000
+++ unity-shared/MenuManager.cpp	2015-10-01 03:52:29 +0000
@@ -142,18 +142,18 @@
     {
       auto key = gdk_keyval_to_lower(gdk_unicode_to_keyval(mnemonic));
       glib::String accelerator(gtk_accelerator_name(key, GDK_MOD1_MASK));
-      auto action = std::make_shared<CompAction>();
       auto const& id = entry->id();
 
-      action->keyFromString(accelerator);
-      action->setState(CompAction::StateInitKey);
-      action->setInitiate([this, id] (CompAction* action, CompAction::State, CompOption::Vector&) {
+      CompAction action;
+      action.keyFromString(accelerator);
+      action.setState(CompAction::StateInitKey);
+      action.setInitiate([this, id] (CompAction* action, CompAction::State, CompOption::Vector&) {
         LOG_DEBUG(logger) << "pressed \"" << action->keyToString() << "\"";
         return parent_->key_activate_entry.emit(id);
       });
 
-      entry_actions_.insert({entry, action});
-      key_grabber_->AddAction(*action);
+      if (uint32_t action_id = key_grabber_->AddAction(action))
+        entry_actions_.insert({entry, action_id});
     }
   }
 
@@ -163,7 +163,7 @@
 
     if (it != entry_actions_.end())
     {
-      key_grabber_->RemoveAction(*it->second);
+      key_grabber_->RemoveAction(it->second);
       entry_actions_.erase(it);
     }
   }
@@ -172,7 +172,7 @@
   {
     for (auto it = entry_actions_.begin(); it != entry_actions_.end();)
     {
-      key_grabber_->RemoveAction(*it->second);
+      key_grabber_->RemoveAction(it->second);
       it = entry_actions_.erase(it);
     }
   }
@@ -240,7 +240,7 @@
   connection::Wrapper active_win_conn_;
   glib::Object<GSettings> settings_;
   glib::SignalManager signals_;
-  std::unordered_map<indicator::Entry::Ptr, std::shared_ptr<CompAction>> entry_actions_;
+  std::unordered_map<indicator::Entry::Ptr, uint32_t> entry_actions_;
 };
 
 Manager::Manager(Indicators::Ptr const& indicators, key::Grabber::Ptr const& grabber)

=== modified file 'unity-standalone/StandaloneUnity.cpp'
--- unity-standalone/StandaloneUnity.cpp	2014-02-25 22:10:53 +0000
+++ unity-standalone/StandaloneUnity.cpp	2015-10-01 03:52:29 +0000
@@ -72,12 +72,10 @@
 
 struct StandaloneKeyGrabber : key::Grabber
 {
-  CompAction::Vector& GetActions() { return actions_; }
-  void AddAction(CompAction const&) {}
-  void RemoveAction(CompAction const&) {}
-
-  private:
-    CompAction::Vector actions_;
+  CompAction::Vector& GetActions() override { return noActions(); }
+  uint32_t AddAction(CompAction const&) override { return 0; };
+  bool RemoveAction(CompAction const&) override { return false; };
+  bool RemoveAction(uint32_t id) override { return false; };
 };
 
 class UnityStandalone