Merge lp:~3v1n0/unity/lockscreen-power-keys into lp:unity

[Marco Trevisan (Treviño)]

LockScreenAcceleratorController: do ther configured action on power special keys press

We finally can suspend, shutdown, hibernate or start the screensaver when the screen is locked, using
the Suspend, Sleep, Hibernate and PowerOff hardware keys.

Also the Shutdown dialog doesn't allow now to lock the session if it is not allowed by settings.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3817
http://jenkins.qa.ubuntu.com/job/unity-ci/926/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/13
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/13
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/13

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

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

LGTM

[Christopher Townsend (townsend)]

Oops, meant to approve

review: Approve

[Stephen M. Webb (bregma)]

Merge conflicts when attempting to merge to trunk.

Text conflict in lockscreen/LockScreenController.cpp
Text conflict in shutdown/SessionView.cpp
2 conflicts encountered.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3818
http://jenkins.qa.ubuntu.com/job/unity-ci/974/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/61/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/61/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/61/console

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

review: Needs Fixing (continuous-integration)

[Stephen M. Webb (bregma)]

OK, merges cleanly now

review: Approve

=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2014-04-16 22:03:41 +0000
+++ UnityCore/GnomeSessionManager.cpp	2014-06-18 15:11:36 +0000
@@ -91,6 +91,11 @@
   shell_object_ = shell_server_.GetObject(shell::DBUS_INTERFACE);
   shell_object_->SetMethodsCallsHandler(sigc::mem_fun(this, &Impl::OnShellMethodCall));
 
+  manager_->is_locked = false;
+  manager_->is_locked.changed.connect([this] (bool locked) {
+    locked ? manager_->locked.emit() : manager_->unlocked.emit();
+  });
+
   {
     const char* session_id = test_mode_ ? "id0" : g_getenv("XDG_SESSION_ID");
 
@@ -421,21 +426,13 @@
 {
   EnsureCancelPendingAction();
 
+  if (!manager_->CanLock())
+  {
+    manager_->ScreenSaverActivate();
+    return;
+  }
+
   // FIXME (andy) we should ask gnome-session to emit the logind signal
-  glib::Object<GSettings> lockdown_settings(g_settings_new(GNOME_LOCKDOWN_OPTIONS.c_str()));
-
-  if (g_settings_get_boolean(lockdown_settings, DISABLE_LOCKSCREEN_KEY.c_str()))
-  {
-    manager_->ScreenSaverActivate();
-    return;
-  }
-  else if (manager_->UserName().find("guest-") == 0)
-  {
-    LOG_INFO(logger) << "Impossible to lock a guest session";
-    manager_->ScreenSaverActivate();
-    return;
-  }
-
   prompt ? manager_->prompt_lock_requested.emit() : manager_->lock_requested.emit();
 }
 
@@ -454,6 +451,39 @@
   });
 }
 
+bool GnomeManager::Impl::HasInhibitors()
+{
+  glib::Error error;
+  glib::Object<GDBusConnection> bus(g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error));
+
+  if (error)
+  {
+    LOG_ERROR(logger) << "Impossible to get the session bus, to fetch the inhibitors: " << error;
+    return false;
+  }
+
+  enum class Inhibited : unsigned
+  {
+    LOGOUT = 1,
+    USER_SWITCH = 2,
+    SUSPEND = 4,
+    IDLE_SET = 8
+  };
+
+  glib::Variant inhibitors(g_dbus_connection_call_sync(bus, test_mode_ ? testing::DBUS_NAME.c_str() : "org.gnome.SessionManager",
+                                                       "/org/gnome/SessionManager", "org.gnome.SessionManager",
+                                                       "IsInhibited", g_variant_new("(u)", Inhibited::LOGOUT), nullptr,
+                                                       G_DBUS_CALL_FLAGS_NONE, 500, nullptr, &error));
+
+  if (error)
+  {
+    LOG_ERROR(logger) << "Impossible to get the inhibitors: " << error;
+    return false;
+  }
+
+  return inhibitors.GetBool();
+}
+
 // Public implementation
 
 GnomeManager::GnomeManager()
@@ -617,6 +647,19 @@
   });
 }
 
+bool GnomeManager::CanLock() const
+{
+  glib::Object<GSettings> lockdown_settings(g_settings_new(GNOME_LOCKDOWN_OPTIONS.c_str()));
+
+  if (g_settings_get_boolean(lockdown_settings, DISABLE_LOCKSCREEN_KEY.c_str()) ||
+      UserName().find("guest-") == 0 || is_locked())
+  {
+    return false;
+  }
+
+  return true;
+}
+
 bool GnomeManager::CanShutdown() const
 {
   return impl_->can_shutdown_;
@@ -632,6 +675,11 @@
   return impl_->can_hibernate_;
 }
 
+bool GnomeManager::HasInhibitors() const
+{
+  return impl_->HasInhibitors();
+}
+
 void GnomeManager::CancelAction()
 {
   impl_->CancelAction();
 
=== modified file 'UnityCore/GnomeSessionManager.h'
--- UnityCore/GnomeSessionManager.h	2014-04-10 04:47:58 +0000
+++ UnityCore/GnomeSessionManager.h	2014-06-18 15:11:36 +0000
@@ -47,9 +47,11 @@
   void Suspend();
   void Hibernate();
 
+  bool CanLock() const;
   bool CanShutdown() const;
   bool CanSuspend() const;
   bool CanHibernate() const;
+  bool HasInhibitors() const;
 
   void CancelAction();
 
 
=== modified file 'UnityCore/GnomeSessionManagerImpl.h'
--- UnityCore/GnomeSessionManagerImpl.h	2014-04-16 21:51:45 +0000
+++ UnityCore/GnomeSessionManagerImpl.h	2014-06-18 15:11:36 +0000
@@ -51,6 +51,7 @@
   void ConfirmShutdown();
   void CancelAction();
   void ClosedDialog();
+  bool HasInhibitors();
   void EnsureCancelPendingAction();
   void LockScreen(bool prompt);
 
 
=== modified file 'UnityCore/SessionManager.h'
--- UnityCore/SessionManager.h	2014-04-16 21:51:45 +0000
+++ UnityCore/SessionManager.h	2014-06-18 15:11:36 +0000
@@ -39,6 +39,7 @@
   virtual ~Manager() = default;
 
   nux::ROProperty<bool> have_other_open_sessions;
+  nux::Property<bool> is_locked;
 
   virtual std::string RealName() const = 0;
   virtual std::string UserName() const = 0;
@@ -54,9 +55,11 @@
   virtual void Suspend() = 0;
   virtual void Hibernate() = 0;
 
+  virtual bool CanLock() const = 0;
   virtual bool CanShutdown() const = 0;
   virtual bool CanSuspend() const = 0;
   virtual bool CanHibernate() const = 0;
+  virtual bool HasInhibitors() const = 0;
 
   virtual void CancelAction() = 0;
 
 
=== modified file 'lockscreen/LockScreenAcceleratorController.cpp'
--- lockscreen/LockScreenAcceleratorController.cpp	2014-04-28 13:09:53 +0000
+++ lockscreen/LockScreenAcceleratorController.cpp	2014-06-18 15:11:36 +0000
@@ -32,6 +32,17 @@
 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";
@@ -89,15 +100,32 @@
                     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();
+}
 } // namespace
 
-AcceleratorController::AcceleratorController()
+AcceleratorController::AcceleratorController(session::Manager::Ptr const& session)
   : 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));
+  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)));
@@ -108,6 +136,22 @@
   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());
 
=== modified file 'lockscreen/LockScreenAcceleratorController.h'
--- lockscreen/LockScreenAcceleratorController.h	2014-04-28 13:09:53 +0000
+++ lockscreen/LockScreenAcceleratorController.h	2014-06-18 15:11:36 +0000
@@ -20,6 +20,7 @@
 #ifndef UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 #define UNITY_LOCKSCREEN_ACCELERATOR_CONTROLLER
 
+#include <UnityCore/SessionManager.h>
 #include "LockScreenAccelerators.h"
 
 namespace unity
@@ -32,7 +33,7 @@
 public:
   typedef std::shared_ptr<AcceleratorController> Ptr;
 
-  AcceleratorController();
+  AcceleratorController(session::Manager::Ptr const&);
 
   Accelerators::Ptr const& GetAccelerators() const;
 
 
=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2014-06-07 16:26:59 +0000
+++ lockscreen/LockScreenController.cpp	2014-06-18 15:11:36 +0000
@@ -104,7 +104,7 @@
       key_connection_->disconnect();
       uscreen_connection_->block();
       hidden_window_connection_->block();
-      session_manager_->unlocked.emit();
+      session_manager_->is_locked = false;
 
       std::for_each(shields_.begin(), shields_.end(), [](nux::ObjectPtr<Shield> const& shield) {
         shield->RemoveLayout();
@@ -342,7 +342,7 @@
       HideBlankWindow();
 
     LockScreen();
-    session_manager_->locked.emit();
+    session_manager_->is_locked = true;
 
     if (prompt_activation_)
     {
@@ -403,7 +403,7 @@
   indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
   upstart_wrapper_->Emit("desktop-lock");
 
-  accelerator_controller_ = std::make_shared<AcceleratorController>();
+  accelerator_controller_ = std::make_shared<AcceleratorController>(session_manager_);
   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 'shutdown/SessionDBusManager.cpp'
--- shutdown/SessionDBusManager.cpp	2014-04-10 04:47:58 +0000
+++ shutdown/SessionDBusManager.cpp	2014-06-18 15:11:36 +0000
@@ -53,14 +53,20 @@
     <method name="Suspend" />
     <method name="Hibernate" />
     <method name="CancelAction" />
+    <method name="IsLocked">
+      <arg type="b" direction="out" name="is_locked" />
+    </method>
+    <method name="CanLock">
+      <arg type="b" direction="out" name="can_lock" />
+    </method>
     <method name="CanShutdown">
-      <arg type="b" direction="out" name="canshutdown" />
+      <arg type="b" direction="out" name="can_shutdown" />
     </method>
     <method name="CanSuspend">
-      <arg type="b" direction="out" name="cansuspend" />
+      <arg type="b" direction="out" name="can_suspend" />
     </method>
     <method name="CanHibernate">
-      <arg type="b" direction="out" name="canhibernate" />
+      <arg type="b" direction="out" name="can_hibernate" />
     </method>
 
     <signal name="LockRequested" />
@@ -121,7 +127,7 @@
     }
     else if (method == "RequestLogout")
     {
-      session_->logout_requested.emit(false);
+      session_->logout_requested.emit(session_->HasInhibitors());
     }
     else if (method == "Reboot")
     {
@@ -129,7 +135,7 @@
     }
     else if (method == "RequestReboot")
     {
-      session_->reboot_requested.emit(false);
+      session_->reboot_requested.emit(session_->HasInhibitors());
     }
     else if (method == "Shutdown")
     {
@@ -137,7 +143,7 @@
     }
     else if (method == "RequestShutdown")
     {
-      session_->shutdown_requested.emit(false);
+      session_->shutdown_requested.emit(session_->HasInhibitors());
     }
     else if (method == "Suspend")
     {
@@ -152,17 +158,25 @@
       session_->CancelAction();
       session_->cancel_requested.emit();
     }
+    else if (method == "IsLocked")
+    {
+      return g_variant_new("(b)", session_->is_locked() != false);
+    }
+    else if (method == "CanLock")
+    {
+      return g_variant_new("(b)", session_->CanLock() != false);
+    }
     else if (method == "CanShutdown")
     {
-      return g_variant_new("(b)", session_->CanShutdown() != FALSE);
+      return g_variant_new("(b)", session_->CanShutdown() != false);
     }
     else if (method == "CanSuspend")
     {
-      return g_variant_new("(b)", session_->CanSuspend() != FALSE);
+      return g_variant_new("(b)", session_->CanSuspend() != false);
     }
     else if (method == "CanHibernate")
     {
-      return g_variant_new("(b)", session_->CanHibernate() != FALSE);
+      return g_variant_new("(b)", session_->CanHibernate() != false);
     }
 
     return nullptr;
 
=== modified file 'shutdown/SessionView.cpp'
--- shutdown/SessionView.cpp	2014-06-07 16:26:41 +0000
+++ shutdown/SessionView.cpp	2014-06-18 15:11:36 +0000
@@ -91,16 +91,17 @@
     return false;
   });
 
-  mode.changed.connect([this] (Mode m) {
-    UpdateText();
-    Populate();
-  });
-
+  mode.changed.connect(sigc::hide(sigc::mem_fun(this, &View::UpdateContents)));
   scale.changed.connect(sigc::hide(sigc::mem_fun(this, &View::UpdateViewSize)));
+  UpdateContents();
+}
 
+void View::UpdateContents()
+{
+  SetVisible(true);
+  PopulateButtons();
+  UpdateText();
   UpdateViewSize();
-  UpdateText();
-  Populate();
 }
 
 void View::UpdateViewSize()
@@ -115,11 +116,17 @@
   ReloadCloseButtonTexture();
 
   buttons_layout_->SetSpaceBetweenChildren(style::BUTTONS_SPACE.CP(scale()));
-
-  for (auto* area : buttons_layout_->GetChildren())
+  auto const& buttons = buttons_layout_->GetChildren();
+
+  for (auto* area : buttons)
+    static_cast<Button*>(area)->scale = scale();
+
+  if (buttons.size() == 1)
   {
-    auto* button = static_cast<Button*>(area);
-    button->scale = scale();
+    auto* button = buttons.front();
+    button->ComputeContentSize();
+    int padding = button->GetWidth()/2 + style::MAIN_SPACE.CP(scale())/2;
+    buttons_layout_->SetLeftAndRightPadding(padding, padding);
   }
 }
 
@@ -201,20 +208,26 @@
   subtitle_->SetText(glib::String(g_strdup_printf(message.c_str(), name.c_str())).Str());
 }
 
-void View::Populate()
+void View::PopulateButtons()
 {
   debug::Introspectable::RemoveAllChildren();
   buttons_layout_->Clear();
+  buttons_layout_->SetLeftAndRightPadding(0, 0);
   key_focus_area_ = this;
 
   if (mode() == Mode::LOGOUT)
   {
-    auto* button = new Button(Button::Action::LOCK, NUX_TRACKER_LOCATION);
-    button->scale = scale();
-    button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
-    AddButton(button);
-
-    button = new Button(Button::Action::LOGOUT, NUX_TRACKER_LOCATION);
+    if (manager_->is_locked())
+      return;
+
+    if (manager_->CanLock())
+    {
+      auto* button = new Button(Button::Action::LOCK, NUX_TRACKER_LOCATION);
+      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
+      AddButton(button);
+    }
+
+    auto* button = new Button(Button::Action::LOGOUT, NUX_TRACKER_LOCATION);
     button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Logout));
     key_focus_area_ = button;
     AddButton(button);
@@ -223,23 +236,23 @@
   {
     if (mode() == Mode::FULL)
     {
-      auto* button = new Button(Button::Action::LOCK, NUX_TRACKER_LOCATION);
-      button->scale = scale();
-      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
-      AddButton(button);
+      if (manager_->CanLock())
+      {
+        auto* button = new Button(Button::Action::LOCK, NUX_TRACKER_LOCATION);
+        button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
+        AddButton(button);
+      }
 
       if (manager_->CanSuspend())
       {
-        button = new Button(Button::Action::SUSPEND, NUX_TRACKER_LOCATION);
-        button->scale = scale();
+        auto* button = new Button(Button::Action::SUSPEND, NUX_TRACKER_LOCATION);
         button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Suspend));
         AddButton(button);
       }
 
       if (manager_->CanHibernate())
       {
-        button = new Button(Button::Action::HIBERNATE, NUX_TRACKER_LOCATION);
-        button->scale = scale();
+        auto* button = new Button(Button::Action::HIBERNATE, NUX_TRACKER_LOCATION);
         button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Hibernate));
         AddButton(button);
       }
@@ -248,28 +261,34 @@
     if (manager_->CanShutdown())
     {
       auto *button = new Button(Button::Action::REBOOT, NUX_TRACKER_LOCATION);
-      button->scale = scale();
       button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Reboot));
       AddButton(button);
 
       button = new Button(Button::Action::SHUTDOWN, NUX_TRACKER_LOCATION);
-      button->scale = scale();
       button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Shutdown));
       key_focus_area_ = (mode() == Mode::SHUTDOWN) ? button : key_focus_area_;
       AddButton(button);
     }
-    else if (mode() == Mode::FULL)
+    else if (mode() == Mode::FULL && !manager_->is_locked())
     {
       auto* button = new Button(Button::Action::LOGOUT, NUX_TRACKER_LOCATION);
-      button->scale = scale();
       button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Logout));
       AddButton(button);
     }
   }
+
+  cancel_idle_.reset();
+  if (buttons_layout_->GetChildren().empty())
+  {
+    // There's nothing to show here, let's cancel the action and hide
+    SetVisible(false);
+    cancel_idle_.reset(new glib::Idle([this] { request_close.emit(); return false; }));
+  }
 }
 
 void View::AddButton(Button* button)
 {
+  button->scale = scale();
   button->activated.connect([this] {request_hide.emit();});
   buttons_layout_->AddView(button);
   debug::Introspectable::AddChild(button);
 
=== modified file 'shutdown/SessionView.h'
--- shutdown/SessionView.h	2014-04-25 18:12:48 +0000
+++ shutdown/SessionView.h	2014-06-18 15:11:36 +0000
@@ -25,10 +25,10 @@
 #include <Nux/VLayout.h>
 #include <Nux/HLayout.h>
 
-#include "UnityCore/SessionManager.h"
+#include <UnityCore/GLibSource.h>
+#include <UnityCore/SessionManager.h>
 #include "unity-shared/EMConverter.h"
 #include "unity-shared/UnityWindowView.h"
-#include "UnityCore/SessionManager.h"
 
 namespace unity
 {
@@ -73,10 +73,10 @@
 private:
   friend class TestSessionView;
 
+  void PopulateButtons();
+  void UpdateText();
+  void UpdateContents();
   void UpdateViewSize();
-
-  void UpdateText();
-  void Populate();
   void AddButton(Button*);
 
   Manager::Ptr manager_;
@@ -85,6 +85,7 @@
   nux::VLayout* main_layout_;
   nux::HLayout* buttons_layout_;
   nux::InputArea* key_focus_area_;
+  glib::Source::UniquePtr cancel_idle_;
 };
 
 } // namespace session
 
=== modified file 'shutdown/StandaloneSession.cpp'
--- shutdown/StandaloneSession.cpp	2014-04-10 04:47:58 +0000
+++ shutdown/StandaloneSession.cpp	2014-06-18 15:11:36 +0000
@@ -52,9 +52,11 @@
 
   void CancelAction() { std::cout << "CancelAction" << std::endl; }
 
+  bool CanLock() const {return true;}
   bool CanShutdown() const {return true;}
   bool CanSuspend() const {return true;}
   bool CanHibernate() const {return true;}
+  bool HasInhibitors() const {return false;}
 };
 
 struct SessionWindow
 
=== modified file 'tests/test_mock_session_manager.h'
--- tests/test_mock_session_manager.h	2014-04-10 04:47:58 +0000
+++ tests/test_mock_session_manager.h	2014-06-18 15:11:36 +0000
@@ -44,9 +44,11 @@
   MOCK_METHOD0(Hibernate, void());
   MOCK_METHOD0(CancelAction, void());
 
+  MOCK_CONST_METHOD0(CanLock, bool());
   MOCK_CONST_METHOD0(CanShutdown, bool());
   MOCK_CONST_METHOD0(CanSuspend, bool());
   MOCK_CONST_METHOD0(CanHibernate, bool());
+  MOCK_CONST_METHOD0(HasInhibitors, bool());
 };
 
 } // session
 
=== modified file 'tests/test_session_controller.cpp'
--- tests/test_session_controller.cpp	2014-04-30 15:33:43 +0000
+++ tests/test_session_controller.cpp	2014-06-18 15:11:36 +0000
@@ -41,6 +41,7 @@
     , manager(std::make_shared<testing::NiceMock<MockManager>>())
     , controller(manager)
   {
+    ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(true));
     ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
   }
 
 
=== modified file 'tests/test_session_view.cpp'
--- tests/test_session_view.cpp	2014-03-21 04:40:12 +0000
+++ tests/test_session_view.cpp	2014-06-18 15:11:36 +0000
@@ -137,6 +137,7 @@
 
 TEST_F(TestSessionView, FullModeButtons)
 {
+  ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(true));
   ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
   ON_CALL(*manager, CanSuspend()).WillByDefault(testing::Return(true));
   ON_CALL(*manager, CanHibernate()).WillByDefault(testing::Return(true));
@@ -166,6 +167,11 @@
   view.mode.changed.emit(View::Mode::FULL);
 
   EXPECT_EQ(view.GetButtonByAction(Button::Action::HIBERNATE), nullptr);
+
+  ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(false));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_EQ(view.GetButtonByAction(Button::Action::LOCK), nullptr);
 }
 
 TEST_F(TestSessionView, ShutdownModeButtons)
@@ -181,6 +187,7 @@
 
 TEST_F(TestSessionView, LogoutModeButtons)
 {
+  ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(true));
   view.mode = View::Mode::LOGOUT;
 
   EXPECT_EQ(view.GetButtons().size(), 2);
@@ -189,6 +196,16 @@
   EXPECT_EQ(view.key_focus_area(), view.GetButtonByAction(Button::Action::LOGOUT));
 }
 
+TEST_F(TestSessionView, LogoutLightModeButtons)
+{
+  ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(false));
+  view.mode = View::Mode::LOGOUT;
+
+  EXPECT_EQ(view.GetButtons().size(), 1);
+  EXPECT_EQ(view.GetButtonPosition(Button::Action::LOGOUT), 0);
+  EXPECT_EQ(view.key_focus_area(), view.GetButtonByAction(Button::Action::LOGOUT));
+}
+
 TEST_F(TestSessionView, FullModeTitle)
 {
   EXPECT_TRUE(view.GetTitle().empty());
@@ -213,8 +230,9 @@
 {
   bool request_hide = false;
   view.request_hide.connect([&request_hide] { request_hide = true; });
+  view.mode = View::Mode::LOGOUT;
 
-  auto button = view.GetButtonByAction(Button::Action::LOCK);
+  auto button = view.GetButtonByAction(Button::Action::LOGOUT);
   ASSERT_NE(button, nullptr);
   button->activated.emit();
 
@@ -223,7 +241,8 @@
 
 TEST_F(TestSessionView, ButtonsActivateDeselectButton)
 {
-  auto button = view.GetButtonByAction(Button::Action::LOCK);
+  view.mode = View::Mode::LOGOUT;
+  auto button = view.GetButtonByAction(Button::Action::LOGOUT);
   ASSERT_NE(button, nullptr);
   button->highlighted = true;
   button->activated.emit();
@@ -233,6 +252,8 @@
 
 TEST_F(TestSessionView, LockButtonActivateLocks)
 {
+  ON_CALL(*manager, CanLock()).WillByDefault(testing::Return(true));
+  view.mode = View::Mode::LOGOUT;
   EXPECT_CALL(*manager, LockScreen());
   auto button = view.GetButtonByAction(Button::Action::LOCK);
   ASSERT_NE(button, nullptr);