Merge lp:~3v1n0/unity/lockscreen-media-accelerators into lp:unity

[Marco Trevisan (Treviño)]

LockScreenAcceleratorController: use key::Grabber to handle allowed bindings

This makes U-S-D to handle key events, without having to add some extra
custom code inside the lockscreen. It's all just about whitelisting the
wanted values.

[Andrea Azzarone (azzar1)]

LGTM.

review: Approve

=== modified file 'lockscreen/LockScreenAcceleratorController.cpp'
--- lockscreen/LockScreenAcceleratorController.cpp	2014-05-16 04:51:34 +0000
+++ lockscreen/LockScreenAcceleratorController.cpp	2016-06-21 14:42:21 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2014-2016 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -15,10 +15,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: William Hua <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #include "LockScreenAcceleratorController.h"
 
+#include <NuxCore/Logger.h>
 #include <UnityCore/GLibDBusProxy.h>
 
 namespace unity
@@ -28,157 +30,150 @@
 
 namespace
 {
-const char* const MEDIA_KEYS_SCHEMA                = "org.gnome.settings-daemon.plugins.media-keys";
-const char* const MEDIA_KEYS_KEY_VOLUME_MUTE       = "volume-mute";
-const char* const MEDIA_KEYS_KEY_VOLUME_DOWN       = "volume-down";
-const char* const MEDIA_KEYS_KEY_VOLUME_UP         = "volume-up";
-
-const char* const POWER_SCHEMA                     = "org.gnome.settings-daemon.plugins.power";
-const char* const SUSPEND_BUTTON_ACTION_KEY        = "button-suspend";
-const char* const SLEEP_BUTTON_ACTION_KEY          = "button-sleep";
-const char* const HIBERNATE_BUTTON_ACTION_KEY      = "button-hibernate";
-const char* const POWER_BUTTON_ACTION_KEY          = "button-power";
-const char* const POWER_KEY_SUSPEND                = "XF86Suspend";
-const char* const POWER_KEY_SLEEP                  = "XF86Sleep";
-const char* const POWER_KEY_HIBERNATE              = "XF86Hibernate";
-const char* const POWER_KEY_POWEROFF               = "XF86PowerOff";
-
-const char* const INPUT_SWITCH_SCHEMA              = "org.gnome.desktop.wm.keybindings";
-const char* const INPUT_SWITCH_KEY_PREVIOUS_SOURCE = "switch-input-source-backward";
-const char* const INPUT_SWITCH_KEY_NEXT_SOURCE     = "switch-input-source";
-
-const char* const INDICATOR_INTERFACE_ACTIONS      = "org.gtk.Actions";
-const char* const INDICATOR_METHOD_ACTIVATE        = "Activate";
-const char* const INDICATOR_SOUND_BUS_NAME         = "com.canonical.indicator.sound";
-const char* const INDICATOR_SOUND_OBJECT_PATH      = "/com/canonical/indicator/sound";
-const char* const INDICATOR_SOUND_ACTION_MUTE      = "mute";
-const char* const INDICATOR_SOUND_ACTION_SCROLL    = "scroll";
-const char* const INDICATOR_KEYBOARD_BUS_NAME      = "com.canonical.indicator.keyboard";
-const char* const INDICATOR_KEYBOARD_OBJECT_PATH   = "/com/canonical/indicator/keyboard";
-const char* const INDICATOR_KEYBOARD_ACTION_SCROLL = "locked_scroll";
-
-void ActivateIndicator(std::string const& bus_name,
-                       std::string const& object_path,
-                       std::string const& action_name,
-                       glib::Variant const& parameters = glib::Variant())
-{
-  GVariantBuilder builder;
-
-  g_variant_builder_init(&builder, G_VARIANT_TYPE("(sava{sv})"));
-  g_variant_builder_add(&builder, "s", action_name.c_str());
-
-  if (parameters)
-    g_variant_builder_add_parsed(&builder, "[%v]", static_cast<GVariant*>(parameters));
-  else
-    g_variant_builder_add_parsed(&builder, "@av []");
-
-  g_variant_builder_add_parsed(&builder, "@a{sv} []");
-
-  auto proxy = std::make_shared<glib::DBusProxy>(bus_name, object_path, INDICATOR_INTERFACE_ACTIONS);
-  proxy->CallBegin(INDICATOR_METHOD_ACTIVATE, g_variant_builder_end(&builder), [proxy] (GVariant*, glib::Error const&) {});
-}
-
-void MuteIndicatorSound()
-{
-  ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
-                    INDICATOR_SOUND_OBJECT_PATH,
-                    INDICATOR_SOUND_ACTION_MUTE);
-}
-
-void ScrollIndicatorSound(int offset)
-{
-  ActivateIndicator(INDICATOR_SOUND_BUS_NAME,
-                    INDICATOR_SOUND_OBJECT_PATH,
-                    INDICATOR_SOUND_ACTION_SCROLL,
-                    g_variant_new_int32(offset));
-}
-
-void ScrollIndicatorKeyboard(int offset)
-{
-  ActivateIndicator(INDICATOR_KEYBOARD_BUS_NAME,
-                    INDICATOR_KEYBOARD_OBJECT_PATH,
-                    INDICATOR_KEYBOARD_ACTION_SCROLL,
-                    g_variant_new_int32(-offset));
-}
-
-void PowerAction(session::Manager::Ptr const& session, const char *action_key)
-{
-  glib::Object<GSettings> settings(g_settings_new(POWER_SCHEMA));
-  auto const& action = glib::String(g_settings_get_string(settings, action_key)).Str();
-
-  if (action == "interactive")
-    session->shutdown_requested.emit(session->HasInhibitors());
-  else if (action == "shutdown")
-    session->reboot_requested.emit(session->HasInhibitors());
-  else if (action == "suspend")
-    session->Suspend();
-  else if (action == "hibernate")
-    session->Hibernate();
-  else if (action == "blank")
-    session->ScreenSaverActivate();
-}
+DECLARE_LOGGER(logger, "unity.lockscreen.accelerator.controller");
+
+const std::string MEDIA_KEYS_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys";
+const std::vector<std::string> ALLOWED_MEDIA_KEYS = {
+  "logout",
+  "magnifier",
+  "on-screen-keyboard",
+  "magnifier-zoom-in",
+  "screenreader",
+  "pause",
+  "stop",
+  "toggle-contrast",
+  "video-out",
+  "volume-down",
+  "volume-mute",
+  "volume-up",
+};
+
+const std::string WM_KEYS_SCHEMA = "org.gnome.desktop.wm.keybindings";
+const std::vector<std::string> ALLOWED_WM_KEYS = {
+  "switch-input-source",
+  "switch-input-source-backward",
+};
+
+const std::vector<std::string> ALLOWED_XF86_KEYS = {
+  "XF86ScreenSaver",
+  "XF86Sleep",
+  "XF86Standby",
+  "XF86Suspend",
+  "XF86Hibernate",
+  "XF86PowerOff",
+  "XF86MonBrightnessUp",
+  "XF86MonBrightnessDown",
+  "XF86KbdBrightnessUp",
+  "XF86KbdBrightnessDown",
+  "XF86KbdLightOnOff",
+  "XF86AudioMicMute",
+  "XF86Touchpad",
+};
+
+bool IsKeyBindingAllowed(std::string const& key)
+{
+  if (std::find(begin(ALLOWED_XF86_KEYS), end(ALLOWED_XF86_KEYS), key) != end(ALLOWED_XF86_KEYS))
+    return true;
+
+  glib::Object<GSettings> media_settings(g_settings_new(MEDIA_KEYS_SCHEMA.c_str()));
+  Accelerator key_accelerator(key);
+
+  for (auto const& setting : ALLOWED_MEDIA_KEYS)
+  {
+    Accelerator media_key(glib::String(g_settings_get_string(media_settings, setting.c_str())).Str());
+    if (media_key == key_accelerator)
+      return true;
+  }
+
+  glib::Object<GSettings> wm_settings(g_settings_new(WM_KEYS_SCHEMA.c_str()));
+
+  for (auto const& setting : ALLOWED_WM_KEYS)
+  {
+    glib::Variant accels(g_settings_get_value(wm_settings, setting.c_str()), glib::StealRef());
+    auto children = g_variant_n_children(accels);
+
+    if (children > 0)
+    {
+      glib::String value;
+
+      for (auto i = 0u; i < children; ++i)
+      {
+        g_variant_get_child(accels, 0, "s", &value);
+
+        if (Accelerator(value.Str()) == key_accelerator)
+          return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 } // namespace
 
-AcceleratorController::AcceleratorController(session::Manager::Ptr const& session)
+AcceleratorController::AcceleratorController(key::Grabber::Ptr const& key_grabber)
   : accelerators_(new Accelerators)
 {
-  auto settings = glib::Object<GSettings>(g_settings_new(MEDIA_KEYS_SCHEMA));
-
-  auto accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_MUTE)));
-  accelerator->activated.connect(std::function<void()>(MuteIndicatorSound));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_DOWN)));
-  accelerator->activated.connect(std::bind(ScrollIndicatorSound, -1));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(glib::String(g_settings_get_string(settings, MEDIA_KEYS_KEY_VOLUME_UP)));
-  accelerator->activated.connect(std::bind(ScrollIndicatorSound, +1));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(POWER_KEY_SUSPEND);
-  accelerator->activated.connect(std::bind(PowerAction, session, SUSPEND_BUTTON_ACTION_KEY));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(POWER_KEY_SLEEP);
-  accelerator->activated.connect(std::bind(PowerAction, session, SLEEP_BUTTON_ACTION_KEY));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(POWER_KEY_HIBERNATE);
-  accelerator->activated.connect(std::bind(PowerAction, session, HIBERNATE_BUTTON_ACTION_KEY));
-  accelerators_->Add(accelerator);
-
-  accelerator = std::make_shared<Accelerator>(POWER_KEY_POWEROFF);
-  accelerator->activated.connect(std::bind(PowerAction, session, POWER_BUTTON_ACTION_KEY));
-  accelerators_->Add(accelerator);
-
-  settings = glib::Object<GSettings>(g_settings_new(INPUT_SWITCH_SCHEMA));
-
-  auto variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_PREVIOUS_SOURCE), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar* string;
-
-    g_variant_get_child(variant, 0, "&s", &string);
-
-    accelerator = std::make_shared<Accelerator>(string);
-    accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, -1));
-    accelerators_->Add(accelerator);
-  }
-
-  variant = glib::Variant(g_settings_get_value(settings, INPUT_SWITCH_KEY_NEXT_SOURCE), glib::StealRef());
-
-  if (g_variant_n_children(variant) > 0)
-  {
-    const gchar* string;
-
-    g_variant_get_child(variant, 0, "&s", &string);
-
-    accelerator = std::make_shared<Accelerator>(string);
-    accelerator->activated.connect(std::bind(ScrollIndicatorKeyboard, +1));
-    accelerators_->Add(accelerator);
-  }
+  for (auto const& action : key_grabber->GetActions())
+    AddAction(action);
+
+  key_grabber->action_added.connect(sigc::mem_fun(this, &AcceleratorController::AddAction));
+  key_grabber->action_removed.connect(sigc::mem_fun(this, &AcceleratorController::RemoveAction));
+}
+
+void AcceleratorController::AddAction(CompAction const& action)
+{
+  if (action.type() != CompAction::BindingTypeKey)
+    return;
+
+  auto const& key = action.keyToString();
+
+  if (!IsKeyBindingAllowed(key))
+  {
+    LOG_DEBUG(logger) << "Action not allowed " << key;
+    return;
+  }
+
+  auto accelerator = std::make_shared<Accelerator>(key);
+  accelerator->activated.connect(sigc::bind(sigc::mem_fun(this, &AcceleratorController::OnActionActivated), action));
+  accelerators_->Add(accelerator);
+  actions_accelerators_.push_back({action, accelerator});
+
+  LOG_DEBUG(logger) << "Action added " << key;
+}
+
+void AcceleratorController::RemoveAction(CompAction const& action)
+{
+  if (action.type() != CompAction::BindingTypeKey)
+    return;
+
+  LOG_DEBUG(logger) << "Removing action " << action.keyToString();
+
+  for (auto it = begin(actions_accelerators_); it != end(actions_accelerators_);)
+  {
+    if (it->first == action)
+    {
+      accelerators_->Remove(it->second);
+      it = actions_accelerators_.erase(it);
+    }
+    else
+    {
+      ++it;
+    }
+  }
+}
+
+void AcceleratorController::OnActionActivated(CompAction& action)
+{
+  LOG_DEBUG(logger) << "Activating action " << action.keyToString();
+
+  CompOption::Vector options;
+
+  if (action.state() & CompAction::StateInitKey)
+    action.initiate()(&action, 0, options);
+
+  if (action.state() & CompAction::StateTermKey)
+    action.terminate()(&action, CompAction::StateTermTapped, options);
 }
 
 Accelerators::Ptr const& AcceleratorController::GetAccelerators() const
 
=== modified file 'lockscreen/LockScreenAcceleratorController.h'
--- lockscreen/LockScreenAcceleratorController.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenAcceleratorController.h	2016-06-21 14:42:21 +0000
@@ -20,7 +20,7 @@
 #ifndef UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 #define UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 
-#include "UnityCore/SessionManager.h"
+#include "unity-shared/KeyGrabber.h"
 #include "LockScreenAccelerators.h"
 
 namespace unity
@@ -28,16 +28,21 @@
 namespace lockscreen
 {
 
-class AcceleratorController
+class AcceleratorController : public sigc::trackable
 {
 public:
   typedef std::shared_ptr<AcceleratorController> Ptr;
 
-  AcceleratorController(session::Manager::Ptr const&);
+  AcceleratorController(key::Grabber::Ptr const&);
 
   Accelerators::Ptr const& GetAccelerators() const;
 
 private:
+  void AddAction(CompAction const&);
+  void RemoveAction(CompAction const&);
+  void OnActionActivated(CompAction&);
+
+  std::vector<std::pair<CompAction, Accelerator::Ptr>> actions_accelerators_;
   Accelerators::Ptr accelerators_;
 };
 
 
=== modified file 'lockscreen/LockScreenAccelerators.cpp'
--- lockscreen/LockScreenAccelerators.cpp	2014-04-30 04:34:40 +0000
+++ lockscreen/LockScreenAccelerators.cpp	2016-06-21 14:42:21 +0000
@@ -417,6 +417,11 @@
 {
 }
 
+Accelerators::Vector Accelerators::GetAccelerators() const
+{
+  return accelerators_;
+}
+
 void Accelerators::Clear()
 {
   accelerators_.clear();
 
=== modified file 'lockscreen/LockScreenAccelerators.h'
--- lockscreen/LockScreenAccelerators.h	2014-05-12 19:28:48 +0000
+++ lockscreen/LockScreenAccelerators.h	2016-06-21 14:42:21 +0000
@@ -69,9 +69,11 @@
 {
 public:
   typedef std::shared_ptr<Accelerators> Ptr;
+  typedef std::vector<Accelerator::Ptr> Vector;
 
   Accelerators();
 
+  Accelerators::Vector GetAccelerators() const;
   void Clear();
 
   void Add(Accelerator::Ptr const& accelerator);
@@ -83,7 +85,7 @@
                         unsigned int modifiers);
 
 private:
-  std::vector<Accelerator::Ptr> accelerators_;
+  Accelerators::Vector accelerators_;
 
   PressedState pressed_state_;
 };
 
=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2016-04-15 05:32:41 +0000
+++ lockscreen/LockScreenController.cpp	2016-06-21 14:42:21 +0000
@@ -54,12 +54,14 @@
 
 Controller::Controller(DBusManager::Ptr const& dbus_manager,
                        session::Manager::Ptr const& session_manager,
+                       key::Grabber::Ptr const& key_grabber,
                        UpstartWrapper::Ptr const& upstart_wrapper,
                        ShieldFactoryInterface::Ptr const& shield_factory,
                        bool test_mode)
   : opacity([this] { return fade_animator_.GetCurrentValue(); })
   , dbus_manager_(dbus_manager)
   , session_manager_(session_manager)
+  , key_grabber_(key_grabber)
   , upstart_wrapper_(upstart_wrapper)
   , shield_factory_(shield_factory)
   , suspend_inhibitor_manager_(std::make_shared<SuspendInhibitorManager>())
@@ -459,7 +461,7 @@
   indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
   upstart_wrapper_->Emit("desktop-lock");
 
-  accelerator_controller_ = std::make_shared<AcceleratorController>(session_manager_);
+  accelerator_controller_ = std::make_shared<AcceleratorController>(key_grabber_);
   auto activate_key = WindowManager::Default().activate_indicators_key();
   auto accelerator = std::make_shared<Accelerator>(activate_key.second, 0, activate_key.first);
   accelerator->activated.connect(std::bind(std::mem_fn(&Controller::ActivatePanel), this));
 
=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2016-03-31 09:59:30 +0000
+++ lockscreen/LockScreenController.h	2016-06-21 14:42:21 +0000
@@ -30,6 +30,7 @@
 #include "SuspendInhibitorManager.h"
 #include "ScreenSaverDBusManager.h"
 #include "unity-shared/BackgroundEffectHelper.h"
+#include "unity-shared/KeyGrabber.h"
 #include "unity-shared/UpstartWrapper.h"
 
 namespace unity
@@ -44,7 +45,7 @@
 public:
   typedef std::shared_ptr<Controller> Ptr;
 
-  Controller(DBusManager::Ptr const&, session::Manager::Ptr const&,
+  Controller(DBusManager::Ptr const&, session::Manager::Ptr const&, key::Grabber::Ptr const&,
              UpstartWrapper::Ptr const& upstart_wrapper = std::make_shared<UpstartWrapper>(),
              ShieldFactoryInterface::Ptr const& shield_factory = std::make_shared<ShieldFactory>(),
              bool test_mode = false);
@@ -84,6 +85,7 @@
 
   DBusManager::Ptr dbus_manager_;
   session::Manager::Ptr session_manager_;
+  key::Grabber::Ptr key_grabber_;
   indicator::Indicators::Ptr indicators_;
   AcceleratorController::Ptr accelerator_controller_;
   UpstartWrapper::Ptr upstart_wrapper_;
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2016-06-06 14:28:29 +0000
+++ plugins/unityshell/src/unityshell.cpp	2016-06-21 14:42:21 +0000
@@ -4081,24 +4081,24 @@
   ShowFirstRunHints();
 
   // Setup Session Controller
-  auto manager = std::make_shared<session::GnomeManager>();
-  manager->lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
-  manager->prompt_lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
-  manager->locked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenLocked));
-  manager->unlocked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenUnlocked));
-  session_dbus_manager_ = std::make_shared<session::DBusManager>(manager);
-  session_controller_ = std::make_shared<session::Controller>(manager);
+  auto session = std::make_shared<session::GnomeManager>();
+  session->lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
+  session->prompt_lock_requested.connect(sigc::mem_fun(this, &UnityScreen::OnLockScreenRequested));
+  session->locked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenLocked));
+  session->unlocked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenUnlocked));
+  session_dbus_manager_ = std::make_shared<session::DBusManager>(session);
+  session_controller_ = std::make_shared<session::Controller>(session);
   LOG_INFO(logger) << "InitUnityComponents-Session " << timer.ElapsedSeconds() << "s";
   Introspectable::AddChild(session_controller_.get());
 
   // Setup Lockscreen Controller
-  screensaver_dbus_manager_ = std::make_shared<lockscreen::DBusManager>(manager);
-  lockscreen_controller_ = std::make_shared<lockscreen::Controller>(screensaver_dbus_manager_, manager);
+  screensaver_dbus_manager_ = std::make_shared<lockscreen::DBusManager>(session);
+  lockscreen_controller_ = std::make_shared<lockscreen::Controller>(screensaver_dbus_manager_, session, menus_->KeyGrabber());
   UpdateActivateIndicatorsKey();
   LOG_INFO(logger) << "InitUnityComponents-Lockscreen " << timer.ElapsedSeconds() << "s";
 
   if (g_file_test((DesktopUtilities::GetUserRuntimeDirectory()+local::LOCKED_STAMP).c_str(), G_FILE_TEST_EXISTS))
-    manager->PromptLockScreen();
+    session->PromptLockScreen();
 
   auto on_launcher_size_changed = [this] (nux::Area* area, int w, int h) {
     /* The launcher geometry includes 1px used to draw the right/top margin
 
=== modified file 'tests/test_lockscreen_controller.cpp'
--- tests/test_lockscreen_controller.cpp	2015-12-05 07:03:25 +0000
+++ tests/test_lockscreen_controller.cpp	2016-06-21 14:42:21 +0000
@@ -33,6 +33,7 @@
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UScreen.h"
+#include "mock_key_grabber.h"
 #include "test_mock_session_manager.h"
 #include "test_uscreen_mock.h"
 #include "test_utils.h"
@@ -80,19 +81,21 @@
   TestLockScreenController()
     : animation_controller(tick_source)
     , session_manager(std::make_shared<NiceMock<session::MockManager>>())
+    , key_grabber(std::make_shared<key::MockGrabber::Nice>())
     , dbus_manager(std::make_shared<DBusManager>(session_manager))
     , upstart_wrapper(std::make_shared<UpstartWrapper>())
     , shield_factory(std::make_shared<ShieldFactoryMock>())
-    , controller(dbus_manager, session_manager, upstart_wrapper, shield_factory)
+    , controller(dbus_manager, session_manager, key_grabber, upstart_wrapper, shield_factory)
   {}
 
   struct ControllerWrap : Controller
   {
     ControllerWrap(DBusManager::Ptr const& dbus_manager,
                    session::Manager::Ptr const& session_manager,
+                   key::Grabber::Ptr const& key_grabber,
                    UpstartWrapper::Ptr const& upstart_wrapper,
                    ShieldFactoryInterface::Ptr const& shield_factory)
-      : Controller(dbus_manager, session_manager, upstart_wrapper, shield_factory, /* test_mode */ true)
+      : Controller(dbus_manager, session_manager, key_grabber, upstart_wrapper, shield_factory, /* test_mode */ true)
     {}
 
     using Controller::shields_;
@@ -107,6 +110,7 @@
   unity::panel::Style panel_style;
   unity::lockscreen::Settings lockscreen_settings;
   session::MockManager::Ptr session_manager;
+  key::MockGrabber::Ptr key_grabber;
   DBusManager::Ptr dbus_manager;
   unity::UpstartWrapper::Ptr upstart_wrapper;
 
@@ -123,7 +127,7 @@
 {
   size_t before = uscreen.changed.size();
   {
-    Controller dummy(dbus_manager, session_manager);
+    Controller dummy(dbus_manager, session_manager, key_grabber);
   }
   ASSERT_EQ(before, uscreen.changed.size());
 
@@ -135,7 +139,7 @@
 {
   size_t before = session_manager->unlock_requested.size();
   {
-    Controller dummy(dbus_manager, session_manager);
+    Controller dummy(dbus_manager, session_manager, key_grabber);
   }
   ASSERT_EQ(before, session_manager->unlock_requested.size());
 
 
=== modified file 'unity-shared/GnomeKeyGrabber.cpp'
--- unity-shared/GnomeKeyGrabber.cpp	2016-05-30 16:10:12 +0000
+++ unity-shared/GnomeKeyGrabber.cpp	2016-06-21 14:42:21 +0000
@@ -70,8 +70,9 @@
 std::string const DBUS_NAME = "com.canonical.Unity.Test.GnomeKeyGrabber";
 }
 
-GnomeGrabber::Impl::Impl(bool test_mode)
-  : screen_(screen)
+GnomeGrabber::Impl::Impl(Grabber* parent, bool test_mode)
+  : parent_(parent)
+  , screen_(screen)
   , shell_server_(test_mode ? testing::DBUS_NAME : shell::DBUS_NAME)
   , settings_(g_settings_new(SETTINGS_NAME.c_str()))
   , current_action_id_(0)
@@ -123,6 +124,7 @@
     actions_ids_.push_back(action_id);
     actions_.push_back(action);
     actions_customers_.push_back(1);
+    parent_->action_added.emit(action);
     return true;
   }
 
@@ -178,6 +180,7 @@
   LOG_DEBUG(logger) << "RemoveAction (\"" << action->keyToString() << "\")";
 
   screen_->removeAction(action);
+  parent_->action_removed.emit(*action);
   actions_.erase(actions_.begin() + index);
   actions_ids_.erase(actions_ids_.begin() + index);
   actions_customers_.erase(actions_customers_.begin() + index);
@@ -259,7 +262,6 @@
     action.setState(CompAction::StateInitKey | CompAction::StateTermKey);
     action.setTerminate([this, action_id](CompAction* action, CompAction::State state, CompOption::Vector& options) {
       auto key = action->keyToString();
-
       LOG_DEBUG(logger) << "released \"" << key << "\"";
 
       if (state & CompAction::StateTermTapped)
@@ -353,11 +355,11 @@
 // Public implementation
 
 GnomeGrabber::GnomeGrabber()
-  : impl_(new Impl())
+  : impl_(new Impl(this))
 {}
 
 GnomeGrabber::GnomeGrabber(TestMode const& dummy)
-  : impl_(new Impl(true))
+  : impl_(new Impl(this, true))
 {}
 
 GnomeGrabber::~GnomeGrabber()
 
=== modified file 'unity-shared/GnomeKeyGrabberImpl.h'
--- unity-shared/GnomeKeyGrabberImpl.h	2016-05-30 15:54:34 +0000
+++ unity-shared/GnomeKeyGrabberImpl.h	2016-06-21 14:42:21 +0000
@@ -37,7 +37,7 @@
 
 struct GnomeGrabber::Impl
 {
-  Impl(bool test_mode = false);
+  Impl(Grabber*, bool test_mode = false);
   ~Impl();
 
   uint32_t NextActionID();
@@ -55,9 +55,9 @@
   void ActivateDBusAction(CompAction const& action, uint32_t id, uint32_t device, uint32_t timestamp) const;
 
   bool IsActionPostponed(CompAction const& action) const;
-
   void UpdateWhitelist();
 
+  Grabber* parent_;
   CompScreen* screen_;
 
   glib::DBusServer shell_server_;
 
=== modified file 'unity-shared/KeyGrabber.h'
--- unity-shared/KeyGrabber.h	2015-09-29 13:06:46 +0000
+++ unity-shared/KeyGrabber.h	2016-06-21 14:42:21 +0000
@@ -21,6 +21,7 @@
 #define __UNITY_KEY_GRABBER__
 
 #include <core/core.h>
+#include <sigc++/signal.h>
 
 namespace unity
 {
@@ -36,6 +37,9 @@
   virtual bool RemoveAction(CompAction const&) = 0;
   virtual bool RemoveAction(uint32_t id) = 0;
 
+  sigc::signal<void, CompAction const&> action_added;
+  sigc::signal<void, CompAction const&> action_removed;
+
   virtual CompAction::Vector& GetActions() = 0;
 };