Merge lp:~azzar1/unity/unmap-on-shutdown into lp:unity

[Andrea Azzarone]

Unmap all windows during shutdown.

== Problem ==
#1370017 Unity Lockscreen shows unlocked desktop while shutting down

== Fix ==
Unmap all windows during shutdown.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

Very nice... Just few comments.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

Some comments.

Can you also move SignalHandlers definition to use an std::unordered_map?

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Andrea Azzarone (azzar1)]

> Some comments.
>
> Can you also move SignalHandlers definition to use an std::unordered_map?

Done.

[Marco Trevisan (Treviño) (3v1n0)]

+1

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3890
http://jenkins.qa.ubuntu.com/job/unity-ci/1108/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/195/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/195
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/195

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

review: Needs Fixing (continuous-integration)

=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2013-11-19 18:48:35 +0000
+++ UnityCore/GLibDBusProxy.cpp	2014-10-22 15:33:14 +0000
@@ -21,7 +21,7 @@
 
 #include "GLibDBusProxy.h"
 
-#include <map>
+#include <unordered_map>
 #include <memory>
 #include <NuxCore/Logger.h>
 #include <vector>
@@ -30,6 +30,8 @@
 #include "GLibSignal.h"
 #include "GLibSource.h"
 
+#include <gio/gunixfdlist.h>
+
 namespace unity
 {
 namespace glib
@@ -47,7 +49,7 @@
 {
 public:
   typedef std::vector<ReplyCallback> Callbacks;
-  typedef std::map<string, Callbacks> SignalHandlers;
+  typedef std::unordered_map<string, Callbacks> SignalHandlers;
 
   Impl(DBusProxy* owner,
        string const& name,
@@ -74,6 +76,12 @@
             GCancellable *cancellable,
             GDBusCallFlags flags,
             int timeout_msec);
+  void CallWithUnixFdList(std::string const& method_name,
+                          GVariant* parameters,
+                          CallFinishedCallback const& callback,
+                          GCancellable *cancellable,
+                          GDBusCallFlags flags,
+                          int timeout_msec);
 
   void Connect(string const& signal_name, ReplyCallback const& callback);
   void DisconnectSignal(string const& signal_name);
@@ -85,6 +93,7 @@
 
   static void OnProxyConnectCallback(GObject* source, GAsyncResult* res, gpointer impl);
   static void OnCallCallback(GObject* source, GAsyncResult* res, gpointer call_data);
+  static void OnCallWithUnixFdListCallback(GObject* source, GAsyncResult* res, gpointer call_data);
 
   struct CallData
   {
@@ -399,6 +408,50 @@
                     data);
 }
 
+void DBusProxy::Impl::CallWithUnixFdList(string const& method_name,
+                                         GVariant* parameters,
+                                         CallFinishedCallback const& callback,
+                                         GCancellable* cancellable,
+                                         GDBusCallFlags flags,
+                                         int timeout_msec)
+{
+  GCancellable* target_canc = cancellable != NULL ? cancellable : cancellable_;
+
+  if (!proxy_)
+  {
+    glib::Variant sinked_parameters(parameters);
+    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);
+        LOG_WARNING(logger) << "Cannot call method " << method_name
+                            << ": " << err;
+      }
+      else
+      {
+        CallWithUnixFdList(method_name, sinked_parameters, callback, canc, flags, timeout_msec);
+      }
+    });
+    return;
+  }
+
+  CallData* data = new CallData();
+  data->callback = callback;
+  data->method_name = method_name;
+
+  g_dbus_proxy_call_with_unix_fd_list(proxy_,
+                                      method_name.c_str(),
+                                      parameters,
+                                      flags,
+                                      timeout_msec,
+                                      nullptr,
+                                      target_canc,
+                                      DBusProxy::Impl::OnCallWithUnixFdListCallback,
+                                      data);
+}
+
 void DBusProxy::Impl::OnCallCallback(GObject* source, GAsyncResult* res, gpointer call_data)
 {
   glib::Error error;
@@ -407,7 +460,7 @@
 
   if (error)
   {
-    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
     {
       // silently ignore, don't even invoke callback, FIXME: really?
       return;
@@ -425,6 +478,39 @@
     data->callback(result, error);
 }
 
+void DBusProxy::Impl::OnCallWithUnixFdListCallback(GObject* source, GAsyncResult* res, gpointer call_data)
+{
+  glib::Object<GUnixFDList> fd_list;
+
+  glib::Error error;
+  std::unique_ptr<CallData> data(static_cast<CallData*>(call_data));
+  glib::Variant result(g_dbus_proxy_call_with_unix_fd_list_finish(G_DBUS_PROXY(source), &fd_list, res, &error), glib::StealRef());
+
+  if (error)
+  {
+    if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    {
+      // silently ignore, don't even invoke callback, FIXME: really?
+      return;
+    }
+    else
+    {
+      LOG_WARNING(logger) << "Calling method \"" << data->method_name
+        << "\" on object path: \""
+        << g_dbus_proxy_get_object_path(G_DBUS_PROXY(source))
+        << "\" failed: " << error;
+    }
+  }
+
+  if (data->callback)
+  {
+    gint idx;
+    g_variant_get(result, "(h)", &idx);
+    gint fd = g_unix_fd_list_get(fd_list, idx, nullptr);
+    data->callback(glib::Variant(fd), error);
+  }
+}
+
 void DBusProxy::Impl::Connect(std::string const& signal_name, ReplyCallback const& callback)
 {
   if (!callback)
@@ -487,6 +573,17 @@
               timeout_msec);
 }
 
+void DBusProxy::CallWithUnixFdList(std::string const& method_name,
+                                   GVariant* parameters,
+                                   CallFinishedCallback const& callback,
+                                   GCancellable *cancellable,
+                                   GDBusCallFlags flags,
+                                   int timeout_msec)
+{
+  pimpl->CallWithUnixFdList(method_name, parameters, callback, cancellable,
+                            flags, timeout_msec);
+}
+
 glib::Variant DBusProxy::GetProperty(std::string const& name) const
 {
   if (IsConnected())

=== modified file 'UnityCore/GLibDBusProxy.h'
--- UnityCore/GLibDBusProxy.h	2013-03-25 12:09:41 +0000
+++ UnityCore/GLibDBusProxy.h	2014-10-22 15:33:14 +0000
@@ -64,6 +64,12 @@
                  GCancellable *cancellable = nullptr,
                  GDBusCallFlags flags = G_DBUS_CALL_FLAGS_NONE,
                  int timeout_msec = -1);
+  void CallWithUnixFdList(std::string const& method_name,
+                          GVariant* parameters = nullptr,
+                          CallFinishedCallback const& callback = nullptr,
+                          GCancellable *cancellable = nullptr,
+                          GDBusCallFlags flags = G_DBUS_CALL_FLAGS_NONE,
+                          int timeout_msec = -1);
 
   bool IsConnected() const;
 

=== modified file 'UnityCore/GLibWrapper-inl.h'
--- UnityCore/GLibWrapper-inl.h	2012-07-04 20:16:06 +0000
+++ UnityCore/GLibWrapper-inl.h	2014-10-22 15:33:14 +0000
@@ -94,6 +94,18 @@
 }
 
 template <typename T>
+T** Object<T>::operator&()
+{
+  if (object_)
+  {
+    g_object_unref(object_);
+    object_ = nullptr;
+  }
+
+  return &object_;
+}
+
+template <typename T>
 Object<T>::operator bool() const
 {
   return bool(object_);

=== modified file 'UnityCore/GLibWrapper.h'
--- UnityCore/GLibWrapper.h	2013-05-17 16:52:19 +0000
+++ UnityCore/GLibWrapper.h	2014-10-22 15:33:14 +0000
@@ -56,6 +56,7 @@
   operator T* () const;
   operator bool() const;
   T* operator->() const;
+  T** operator&();
   T* RawPtr() const;
   // Release ownership of the object. No unref will occur.
   T* Release();

=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2014-05-16 04:59:06 +0000
+++ UnityCore/GnomeSessionManager.cpp	2014-10-22 15:33:14 +0000
@@ -432,7 +432,6 @@
     return;
   }
 
-  // FIXME (andy) we should ask gnome-session to emit the logind signal
   prompt ? manager_->prompt_lock_requested.emit() : manager_->lock_requested.emit();
 }
 

=== modified file 'lockscreen/CMakeLists.txt'
--- lockscreen/CMakeLists.txt	2014-04-18 11:45:59 +0000
+++ lockscreen/CMakeLists.txt	2014-10-22 15:33:14 +0000
@@ -27,6 +27,8 @@
      LockScreenAcceleratorController.cpp
      LockScreenAccelerators.cpp
      ScreenSaverDBusManager.cpp
+     ShutdownNotifier.cpp
+     SuspendNotifier.cpp
      UserAuthenticatorPam.cpp
      UserPromptView.cpp
      )

=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2014-09-19 18:18:08 +0000
+++ lockscreen/LockScreenController.cpp	2014-10-22 15:33:14 +0000
@@ -20,6 +20,7 @@
 #include "LockScreenController.h"
 
 #include <UnityCore/DBusIndicators.h>
+#include <UnityCore/GLibDBusProxy.h>
 #include <NuxCore/Logger.h>
 
 #include "LockScreenShield.h"
@@ -59,6 +60,7 @@
   , session_manager_(session_manager)
   , upstart_wrapper_(upstart_wrapper)
   , shield_factory_(shield_factory)
+  , suspend_notifier_(std::make_shared<SuspendNotifier>())
   , fade_animator_(LOCK_FADE_DURATION)
   , blank_window_animator_(IDLE_FADE_DURATION)
   , test_mode_(test_mode)
@@ -77,7 +79,7 @@
   });
   hidden_window_connection_->block();
 
-  suspend_connection_ = uscreen->suspending.connect([this] {
+  suspend_notifier_->RegisterInterest([this](){
     if (Settings::Instance().lock_on_suspend())
       session_manager_->PromptLockScreen();
   });
@@ -440,6 +442,11 @@
   indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
   upstart_wrapper_->Emit("desktop-lock");
 
+  shutdown_notifier_ = std::make_shared<ShutdownNotifier>();
+  shutdown_notifier_->RegisterInterest([](){
+    WindowManager::Default().UnmapAllNoNuxWindowsSync();
+  });
+
   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);
@@ -478,6 +485,8 @@
 
 void Controller::OnUnlockRequested()
 {
+  shutdown_notifier_.reset();
+
   lockscreen_timeout_.reset();
   screensaver_post_lock_timeout_.reset();
 

=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2014-09-19 18:18:08 +0000
+++ lockscreen/LockScreenController.h	2014-10-22 15:33:14 +0000
@@ -27,6 +27,8 @@
 #include "LockScreenShieldFactory.h"
 #include "LockScreenAcceleratorController.h"
 #include "ScreenSaverDBusManager.h"
+#include "ShutdownNotifier.h"
+#include "SuspendNotifier.h"
 #include "UserPromptView.h"
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/UpstartWrapper.h"
@@ -86,6 +88,8 @@
   AcceleratorController::Ptr accelerator_controller_;
   UpstartWrapper::Ptr upstart_wrapper_;
   ShieldFactoryInterface::Ptr shield_factory_;
+  ShutdownNotifier::Ptr shutdown_notifier_;
+  SuspendNotifier::Ptr suspend_notifier_;
 
   nux::animation::AnimateValue<double> fade_animator_;
   nux::animation::AnimateValue<double> blank_window_animator_;
@@ -95,7 +99,6 @@
   BlurType old_blur_type_;
 
   connection::Wrapper uscreen_connection_;
-  connection::Wrapper suspend_connection_;
   connection::Wrapper hidden_window_connection_;
   connection::Manager primary_shield_connections_;
 

=== added file 'lockscreen/ShutdownNotifier.cpp'
--- lockscreen/ShutdownNotifier.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/ShutdownNotifier.cpp	2014-10-22 15:33:14 +0000
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2014 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "ShutdownNotifier.h"
+
+#include <NuxCore/Logger.h>
+#include "UnityCore/GLibDBusProxy.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+DECLARE_LOGGER(logger, "unity.lockscreen.shutdownnotifier");
+
+//
+// Private Implementation
+//
+
+class ShutdownNotifier::Impl
+{
+public:
+  Impl();
+  ~Impl();
+
+  bool RegisterInterest(ShutdownCallback const& cb);
+  void UnregisterInterest();
+
+  void Inhibit();
+  void Uninhibit();
+  bool IsInhibited() const;
+
+private:
+  std::shared_ptr<glib::DBusProxy> logind_proxy_;
+  ShutdownCallback cb_;
+  gint delay_inhibit_fd_;
+};
+
+ShutdownNotifier::Impl::Impl()
+  : logind_proxy_(std::make_shared<glib::DBusProxy>("org.freedesktop.login1",
+                                                    "/org/freedesktop/login1",
+                                                    "org.freedesktop.login1.Manager",
+                                                    G_BUS_TYPE_SYSTEM))
+  , delay_inhibit_fd_(-1)
+{}
+
+ShutdownNotifier::Impl::~Impl()
+{
+  UnregisterInterest();
+}
+
+bool ShutdownNotifier::Impl::RegisterInterest(ShutdownCallback const& cb)
+{
+  if (!cb or cb_)
+    return false;
+
+  cb_ = cb;
+
+  Inhibit();
+
+  logind_proxy_->Connect("PrepareForShutdown", [this](GVariant* variant) {
+    bool active = glib::Variant(variant).GetBool();
+
+    if (active)
+    {
+      cb_();
+      UnregisterInterest();
+    }
+  });
+
+  return true;
+}
+
+void ShutdownNotifier::Impl::UnregisterInterest()
+{
+  if (!cb_)
+    return;
+
+  Uninhibit();
+
+  logind_proxy_->DisconnectSignal("PrepareForShutdown");
+  cb_ = nullptr;
+}
+
+void ShutdownNotifier::Impl::Inhibit()
+{
+  if (IsInhibited())
+    return;
+
+  GVariant* args = g_variant_new("(ssss)", "shutdown", "Unity Lockscreen", "Screen is locked", "delay");
+
+  logind_proxy_->CallWithUnixFdList("Inhibit", args, [this] (GVariant* variant, glib::Error const& e) {
+    if (e)
+    {
+      LOG_ERROR(logger) << "Failed to inhbit suspend";
+    }
+    delay_inhibit_fd_ = glib::Variant(variant).GetInt32();
+  });
+}
+
+void ShutdownNotifier::Impl::Uninhibit()
+{
+  if (!IsInhibited())
+    return;
+
+  close(delay_inhibit_fd_);
+  delay_inhibit_fd_ = -1;
+}
+
+bool ShutdownNotifier::Impl::IsInhibited() const
+{
+  return delay_inhibit_fd_ != -1;
+}
+
+//
+// End Private Implementation
+//
+
+ShutdownNotifier::ShutdownNotifier()
+  : pimpl_(new(Impl))
+{}
+
+ShutdownNotifier::~ShutdownNotifier()
+{}
+
+bool ShutdownNotifier::RegisterInterest(ShutdownCallback const& cb)
+{
+  return pimpl_->RegisterInterest(cb);
+}
+
+void ShutdownNotifier::UnregisterInterest()
+{
+  pimpl_->UnregisterInterest();
+}
+
+}
+}

=== added file 'lockscreen/ShutdownNotifier.h'
--- lockscreen/ShutdownNotifier.h	1970-01-01 00:00:00 +0000
+++ lockscreen/ShutdownNotifier.h	2014-10-22 15:33:14 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2014 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITY_LOCKSCREEN_SHUTDOWN_NOTIFIER
+#define UNITY_LOCKSCREEN_SHUTDOWN_NOTIFIER
+
+#include <memory>
+#include <functional>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+typedef std::function<void()> ShutdownCallback;
+
+class ShutdownNotifier
+{
+public:
+  typedef std::shared_ptr<ShutdownNotifier> Ptr;
+
+  ShutdownNotifier();
+  ~ShutdownNotifier();
+
+  bool RegisterInterest(ShutdownCallback const&);
+  void UnregisterInterest();
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl_;
+};
+
+}
+}
+
+#endif

=== added file 'lockscreen/SuspendNotifier.cpp'
--- lockscreen/SuspendNotifier.cpp	1970-01-01 00:00:00 +0000
+++ lockscreen/SuspendNotifier.cpp	2014-10-22 15:33:14 +0000
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2014 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include "SuspendNotifier.h"
+
+#include <NuxCore/Logger.h>
+#include "UnityCore/GLibDBusProxy.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+DECLARE_LOGGER(logger, "unity.lockscreen.suspendnotifier");
+
+//
+// Private Implementation
+//
+
+class SuspendNotifier::Impl
+{
+public:
+  Impl();
+  ~Impl();
+
+  bool RegisterInterest(SuspendCallback const& cb);
+  void UnregisterInterest();
+
+  void Inhibit();
+  void Uninhibit();
+  bool IsInhibited() const;
+
+private:
+  std::shared_ptr<glib::DBusProxy> logind_proxy_;
+  SuspendCallback cb_;
+  gint delay_inhibit_fd_;
+};
+
+SuspendNotifier::Impl::Impl()
+  : logind_proxy_(std::make_shared<glib::DBusProxy>("org.freedesktop.login1",
+                                                    "/org/freedesktop/login1",
+                                                    "org.freedesktop.login1.Manager",
+                                                    G_BUS_TYPE_SYSTEM))
+  , delay_inhibit_fd_(-1)
+{}
+
+SuspendNotifier::Impl::~Impl()
+{
+  UnregisterInterest();
+}
+
+bool SuspendNotifier::Impl::RegisterInterest(SuspendCallback const& cb)
+{
+  if (!cb or cb_)
+    return false;
+
+  cb_ = cb;
+
+  Inhibit();
+
+  logind_proxy_->Connect("PrepareForSleep", [this](GVariant* variant) {
+    bool active = glib::Variant(variant).GetBool();
+
+    if (active) // suspending
+    {
+      cb_();
+      Uninhibit();
+    }
+    else // resuming
+    {
+      Inhibit();
+    }
+  });
+
+  return true;
+}
+
+void SuspendNotifier::Impl::UnregisterInterest()
+{
+  Uninhibit();
+
+  logind_proxy_->DisconnectSignal("PrepareForSleep");
+  cb_ = nullptr;
+}
+
+void SuspendNotifier::Impl::Inhibit()
+{
+  if (IsInhibited())
+    return;
+
+  GVariant* args = g_variant_new("(ssss)", "sleep", "Unity Lockscreen", "Unity wants to lock screen before suspending.", "delay");
+
+  logind_proxy_->CallWithUnixFdList("Inhibit", args, [this] (GVariant* variant, glib::Error const& e) {
+    if (e)
+    {
+      LOG_ERROR(logger) << "Failed to inhbit suspend";
+    }
+    delay_inhibit_fd_ = glib::Variant(variant).GetInt32();
+  });
+}
+
+void SuspendNotifier::Impl::Uninhibit()
+{
+  if (!IsInhibited())
+    return;
+
+  close(delay_inhibit_fd_);
+  delay_inhibit_fd_ = -1;
+}
+
+bool SuspendNotifier::Impl::IsInhibited() const
+{
+  return delay_inhibit_fd_ != -1;
+}
+
+//
+// End Private Implementation
+//
+
+SuspendNotifier::SuspendNotifier()
+  : pimpl_(new(Impl))
+{}
+
+SuspendNotifier::~SuspendNotifier()
+{}
+
+bool SuspendNotifier::RegisterInterest(SuspendCallback const& cb)
+{
+  return pimpl_->RegisterInterest(cb);
+}
+
+void SuspendNotifier::UnregisterInterest()
+{
+  pimpl_->UnregisterInterest();
+}
+
+}
+}

=== added file 'lockscreen/SuspendNotifier.h'
--- lockscreen/SuspendNotifier.h	1970-01-01 00:00:00 +0000
+++ lockscreen/SuspendNotifier.h	2014-10-22 15:33:14 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2014 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITY_LOCKSCREEN_SUSPEND_NOTIFIER
+#define UNITY_LOCKSCREEN_SHUTDOWN_NOTIFIER
+
+#include <memory>
+#include <functional>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+typedef std::function<void()> SuspendCallback;
+
+class SuspendNotifier
+{
+public:
+  typedef std::shared_ptr<SuspendNotifier> Ptr;
+
+  SuspendNotifier();
+  ~SuspendNotifier();
+
+  bool RegisterInterest(SuspendCallback const&);
+  void UnregisterInterest();
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl_;
+};
+
+}
+}
+
+#endif
\ No newline at end of file

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2014-10-16 15:10:15 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-10-22 15:33:14 +0000
@@ -2795,23 +2795,6 @@
   return "Unity";
 }
 
-bool isNuxWindow(CompWindow* value)
-{
-  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-  auto id = value->id();
-
-  // iterate loop by hand rather than use std::find as this is considerably faster
-  // we care about performance here because of the high frequency in which this function is
-  // called (nearly every frame)
-  unsigned int size = xwns.size();
-  for (unsigned int i = 0; i < size; ++i)
-  {
-    if (xwns[i] == id)
-      return true;
-  }
-  return false;
-}
-
 void UnityScreen::RaiseInputWindows()
 {
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
@@ -4094,7 +4077,7 @@
   , close_icon_state_(decoration::WidgetState::NORMAL)
   , deco_win_(uScreen->deco_manager_->HandleWindow(window))
   , need_fake_deco_redraw_(false)
-  , is_nux_window_(isNuxWindow(window))
+  , is_nux_window_(PluginAdapter::IsNuxWindow(window))
 {
   WindowInterface::setHandler(window);
   GLWindowInterface::setHandler(gWindow);

=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2014-08-13 23:32:39 +0000
+++ unity-shared/PluginAdapter.cpp	2014-10-22 15:33:14 +0000
@@ -1454,6 +1454,40 @@
     _last_focused_window = NULL;
 }
 
+void PluginAdapter::UnmapAllNoNuxWindowsSync()
+{
+  for (auto const& window : m_Screen->windows())
+  {
+    if (!IsNuxWindow(window) && (window->isMapped() || window->isViewable()))
+    {
+      if (window->overrideRedirect())
+      {
+        XUnmapWindow(m_Screen->dpy(), window->id());
+      }
+      else
+      {
+        window->hide();
+      }
+    }
+  }
+
+  XSync(m_Screen->dpy(), False);
+}
+
+bool PluginAdapter::IsNuxWindow(CompWindow* value)
+{
+  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
+  auto id = value->id();
+
+  unsigned int size = xwns.size();
+  for (unsigned int i = 0; i < size; ++i)
+  {
+    if (xwns[i] == id)
+      return true;
+  }
+  return false;
+}
+
 void PluginAdapter::AddProperties(debug::IntrospectionData& wrapper)
 {
   wrapper.add(GetScreenGeometry())

=== modified file 'unity-shared/PluginAdapter.h'
--- unity-shared/PluginAdapter.h	2014-04-02 21:42:12 +0000
+++ unity-shared/PluginAdapter.h	2014-10-22 15:33:14 +0000
@@ -193,6 +193,9 @@
 
   Window GetTopWindowAbove(Window xid) const;
 
+  void UnmapAllNoNuxWindowsSync();
+  static bool IsNuxWindow(CompWindow* value);
+
 protected:
   PluginAdapter(CompScreen* screen);
   void AddProperties(debug::IntrospectionData&);

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2014-04-02 21:42:12 +0000
+++ unity-shared/StandaloneWindowManager.h	2014-10-22 15:33:14 +0000
@@ -163,6 +163,8 @@
   virtual std::string GetStringProperty(Window window_id, Atom) const;
   virtual std::vector<long> GetCardinalProperty(Window window_id, Atom) const;
 
+  virtual void UnmapAllNoNuxWindowsSync() {};
+
   // Mock functions
   StandaloneWindow::Ptr GetWindowByXid(Window window_id) const;
   void AddStandaloneWindow(StandaloneWindow::Ptr const& window);

=== modified file 'unity-shared/UScreen.cpp'
--- unity-shared/UScreen.cpp	2014-08-05 21:22:40 +0000
+++ unity-shared/UScreen.cpp	2014-10-22 15:33:14 +0000
@@ -40,7 +40,8 @@
   proxy_.Connect("PrepareForSleep", [this] (GVariant* data) {
     gboolean val;
     g_variant_get(data, "(b)", &val);
-    val ? suspending.emit() : resuming.emit();
+    if (!val)
+      resuming.emit();
   });
 
   Refresh();

=== modified file 'unity-shared/UScreen.h'
--- unity-shared/UScreen.h	2014-04-08 16:29:49 +0000
+++ unity-shared/UScreen.h	2014-10-22 15:33:14 +0000
@@ -51,7 +51,6 @@
 
   // <void, primary_monitor, monitors>
   sigc::signal<void, int, std::vector<nux::Geometry> const&> changed;
-  sigc::signal<void> suspending;
   sigc::signal<void> resuming;
 
   const std::string GetMonitorName(int output_number) const;

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2014-08-13 23:32:39 +0000
+++ unity-shared/WindowManager.h	2014-10-22 15:33:14 +0000
@@ -169,6 +169,9 @@
   virtual std::string GetStringProperty(Window, Atom) const = 0;
   virtual std::vector<long> GetCardinalProperty(Window, Atom) const = 0;
 
+  virtual void UnmapAllNoNuxWindowsSync() = 0;
+
+
   // Nux Modifiers, Nux Keycode (= X11 KeySym)
   nux::Property<std::pair<unsigned, unsigned>> close_window_key;
   nux::Property<std::pair<unsigned, unsigned>> activate_indicators_key;