Merge lp:~smspillaz/unity/unity.fix_877778 into lp:unity

[Sam Spilsbury]

Fix UnityShowdesktopHandler brokenness LP#877778

Fix UnityShowdesktopHandler, namely the animation going in the wrong direction, damage being applied at the wrong time, handlers not being removed when they should be. Also use PAINT_WINDOW_NO_CORE_INSTANCE_MASK when the window is fully transparent and set the opacity to MAXINT (since the scale plugin uses this to bypass the no paint mask)

Show Desktop mode was completely broken, but the bug there is mainly about the fact that showdesktoped windows would be invisible in the spread. That's now fixed

Split UnityShowdesktopHandler out into a separate file, created UnityShowdesktopHandlerWindowInterface, UnityWindow inmplements this, test coverage created in test_showdesktop_handler.cpp using Google Mock and Google Test. Also see AP tests.

Fixes LP #877778 - Introduces tests for UnityShowdesktopHandler

== Problem ==

See LP #877778 - in fact, Show Desktop mode was completely broken, but the bug there is mainly about the fact that showdesktoped windows would be invisible in the spread. That's now fixed

== Solution ==

Fix UnityShowdesktopHandler brokenness, namely the animation going in the wrong direction, damage being applied at the wrong time, handlers not being removed when they should be. Also use PAINT_WINDOW_NO_CORE_INSTANCE_MASK when the window is fully transparent and set the opacity to MAXINT (since the scale plugin uses this to bypass the no paint mask)

== Test Coverage ==

Split UnityShowdesktopHandler out into a separate file, created UnityShowdesktopHandlerWindowInterface, UnityWindow inmplements this, test coverage created in test_showdesktop_handler.cpp using Google Mock and Google Test. Also see AP tests.

[Gord Allott (gordallott)]

Great stuff, but needs to conform to our code style :) namely FooBar() methods and _foo instead of mFoo, quick sed should fix it

review: Needs Fixing

[Tim Penhey (thumper)]

On Wed 28 Mar 2012 21:47:21 NZDT, Gord Allott wrote:
> Review: Needs Fixing
>
> Great stuff, but needs to conform to our code style :) namely FooBar() methods and _foo instead of mFoo, quick sed should fix it

s/_foo/foo_/

[Omer Akram (om26er)]

has conflicts.

[Unity Merger (unity-merger)]

No commit message specified.

[Tim Penhey (thumper)]

A few style things:

If you are in namespace unity, you should prefix your classes with Unity.

also

s/ ()/()/g

The tests shouldn't be calling the virtual methods. It should be dealing only with the interface methods.

review: Needs Fixing

[Tim Penhey (thumper)]

> A few style things:
>
> If you are in namespace unity, you should prefix your classes with Unity.

s/should/should not/

=== added file 'plugins/unityshell/src/UnityShowdesktopHandler.cpp'
--- plugins/unityshell/src/UnityShowdesktopHandler.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/UnityShowdesktopHandler.cpp	2012-04-02 01:40:26 +0000
@@ -0,0 +1,215 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * 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.
+ *
+ * Your own copyright notice would go above. You are free to choose whatever
+ * licence you want, just take note that some compiz code is GPL and you will
+ * not be able to re-use it if you want to use a different licence.
+ */
+
+#include <glib.h>
+#include "UnityShowdesktopHandler.h"
+
+namespace unity
+{
+
+UnityShowdesktopHandlerWindowInterface::~UnityShowdesktopHandlerWindowInterface ()
+{
+}
+
+/* 300 ms */
+const unsigned int UnityShowdesktopHandler::fade_time = 300;
+std::list <UnityShowdesktopHandlerWindowInterface *> UnityShowdesktopHandler::animating_windows (0);
+
+bool UnityShowdesktopHandler::ShouldHide (UnityShowdesktopHandlerWindowInterface *wi)
+{
+  if (wi->OverrideRedirect ())
+    return false;
+
+  if (!wi->Managed ())
+    return false;
+
+  if (wi->Grabbed ())
+    return false;
+
+  if (wi->DesktopOrDock ())
+   return false;
+
+  if (wi->SkipTaskbarOrPager ())
+    return false;
+
+  if (wi->Hidden ())
+    if ((wi->ShowDesktopMode () || wi->Shaded ()))
+      return false;
+
+  return true;
+}
+
+guint32 UnityShowdesktopHandler::inhibiting_xid = 0;
+
+void
+UnityShowdesktopHandler::InhibitLeaveShowdesktopMode (guint32 xid)
+{
+  if (!inhibiting_xid)
+    inhibiting_xid = xid;
+}
+
+void
+UnityShowdesktopHandler::AllowLeaveShowdesktopMode (guint32 xid)
+{
+  if (inhibiting_xid == xid)
+    inhibiting_xid = 0;
+}
+
+guint32
+UnityShowdesktopHandler::InhibitingXid ()
+{
+  return inhibiting_xid;
+}
+
+UnityShowdesktopHandler::UnityShowdesktopHandler (UnityShowdesktopHandlerWindowInterface *wi) :
+  showdesktop_handler_window_interface_ (wi),
+  remover_ (wi->InputRemover ()),
+  state_ (StateVisible),
+  progress_ (0.0f)
+{
+}
+
+UnityShowdesktopHandler::~UnityShowdesktopHandler ()
+{
+}
+
+void UnityShowdesktopHandler::FadeOut ()
+{
+  if (state_ != StateVisible && state_ != StateFadeIn)
+    return;
+
+  state_ = UnityShowdesktopHandler::StateFadeOut;
+  progress_ = 0.0f;
+
+  was_hidden_ = showdesktop_handler_window_interface_->Hidden ();
+
+  if (!was_hidden_)
+  {
+    showdesktop_handler_window_interface_->Hide ();
+    showdesktop_handler_window_interface_->NotifyHidden ();
+    remover_->save ();
+    remover_->remove ();
+
+    if (std::find (animating_windows.begin(),
+                   animating_windows.end(),
+		   showdesktop_handler_window_interface_) == animating_windows.end())
+      animating_windows.push_back (showdesktop_handler_window_interface_);
+
+  }
+}
+
+void UnityShowdesktopHandler::FadeIn ()
+{
+  if (state_ != StateInvisible && state_ != StateFadeOut)
+    return;
+
+  state_ = UnityShowdesktopHandler::StateFadeIn;
+
+  if (!was_hidden_)
+  {
+    showdesktop_handler_window_interface_->Show ();
+    showdesktop_handler_window_interface_->NotifyShown ();
+    remover_->restore ();
+
+    if (std::find (animating_windows.begin(),
+                   animating_windows.end(),
+		   showdesktop_handler_window_interface_) == animating_windows.end())
+      animating_windows.push_back(showdesktop_handler_window_interface_);
+  }
+}
+
+UnityShowdesktopHandlerWindowInterface::PostPaintAction UnityShowdesktopHandler::Animate (unsigned int ms)
+{
+  float inc = ms / static_cast <float> (fade_time);
+
+  if (state_ == UnityShowdesktopHandler::StateFadeOut)
+  {
+    progress_ += inc;
+    if (progress_ >= 1.0f)
+    {
+      progress_ = 1.0f;
+      state_ = StateInvisible;
+    }
+  }
+  else if (state_ == StateFadeIn)
+  {
+    progress_ -= inc;
+    if (progress_ <= 0.0f)
+    {
+      progress_ = 0.0f;
+      state_ = StateVisible;
+    }
+  }
+  else if (state_ == StateVisible)
+    return UnityShowdesktopHandlerWindowInterface::PostPaintAction::Remove;
+  else if (state_ == StateInvisible)
+    return UnityShowdesktopHandlerWindowInterface::PostPaintAction::Wait;
+
+  return UnityShowdesktopHandlerWindowInterface::PostPaintAction::Damage;
+}
+
+void UnityShowdesktopHandler::PaintOpacity (unsigned short &opacity)
+{
+  if (progress_ == 1.0f || progress_ == 0.0f)
+    opacity = std::numeric_limits <unsigned short>::max ();
+  else
+    opacity *= (1.0f - progress_);
+}
+
+unsigned int UnityShowdesktopHandler::GetPaintMask ()
+{
+  return (progress_ == 1.0f) ? showdesktop_handler_window_interface_->NoCoreInstanceMask () : 0;
+}
+
+void UnityShowdesktopHandler::HandleShapeEvent ()
+{
+  /* Ignore sent events from the InputRemover */
+  if (remover_)
+  {
+    remover_->save ();
+    remover_->remove ();
+  }
+}
+
+void UnityShowdesktopHandler::WindowFocusChangeNotify ()
+{
+  if (showdesktop_handler_window_interface_->Minimized ())
+  {
+    for (UnityShowdesktopHandlerWindowInterface *w : animating_windows)
+      w->DisableFocus ();
+
+    showdesktop_handler_window_interface_->MoveFocusAway ();
+
+    for (UnityShowdesktopHandlerWindowInterface *w : animating_windows)
+      w->EnableFocus ();
+  }
+}
+
+void UnityShowdesktopHandler::UpdateFrameRegion (CompRegion &r)
+{
+  r = CompRegion ();
+
+  /* Ensure no other plugins can touch this frame region */
+  showdesktop_handler_window_interface_->OverrideFrameRegion (r);
+}
+
+}
+

=== added file 'plugins/unityshell/src/UnityShowdesktopHandler.h'
--- plugins/unityshell/src/UnityShowdesktopHandler.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/UnityShowdesktopHandler.h	2012-04-02 01:40:26 +0000
@@ -0,0 +1,158 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * 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.
+ *
+ * Your own copyright notice would go above. You are free to choose whatever
+ * licence you want, just take note that some compiz code is GPL and you will
+ * not be able to re-use it if you want to use a different licence.
+ */
+#ifndef UNITY_SHOWDESKTOP_HANDLER_H
+#define UNITY_SHOWDESKTOP_HANDLER_H
+
+#include <list>
+#include <algorithm>
+#include <core/region.h>
+
+#include <gio/gio.h>
+
+#include "inputremover.h"
+
+namespace unity
+{
+
+class UnityShowdesktopHandlerWindowInterface
+{
+  public:
+
+    enum class PostPaintAction {
+      Wait = 0,
+      Damage = 1,
+      Remove = 2
+    };
+
+    virtual ~UnityShowdesktopHandlerWindowInterface ();
+
+    void EnableFocus () { DoEnableFocus (); }
+    void DisableFocus () { DoDisableFocus (); }
+
+    bool OverrideRedirect () { return IsOverrideRedirect (); }
+    bool Managed () { return IsManaged (); }
+    bool Grabbed () { return IsGrabbed (); }
+    bool DesktopOrDock () { return IsDesktopOrDock (); }
+    bool SkipTaskbarOrPager () { return IsSkipTaskbarOrPager (); }
+    bool Hidden () { return IsHidden (); }
+    bool Shaded () { return IsShaded (); }
+    bool Minimized () { return IsMinimized (); }
+    bool ShowDesktopMode () { return IsInShowdesktopMode (); }
+    void OverrideFrameRegion (CompRegion &r) { return DoOverrideFrameRegion (r); }
+
+    void Hide () { DoHide (); }
+    void NotifyHidden () { DoNotifyHidden (); }
+    void Show () { DoShow (); }
+    void NotifyShown () { DoNotifyShown (); }
+    void MoveFocusAway () { DoMoveFocusAway (); }
+
+    PostPaintAction HandleAnimations (unsigned int ms) { return DoHandleAnimations (ms); }
+    void AddDamage () { DoAddDamage (); }
+
+    void DeleteHandler () { DoDeleteHandler (); }
+
+    unsigned int NoCoreInstanceMask () { return GetNoCoreInstanceMask (); }
+
+    compiz::WindowInputRemoverInterface::Ptr InputRemover () { return GetInputRemover (); }
+
+  protected:
+
+    virtual void DoEnableFocus () = 0;
+    virtual void DoDisableFocus () = 0;
+
+    virtual bool IsOverrideRedirect () = 0;
+    virtual bool IsManaged () = 0;
+    virtual bool IsGrabbed () = 0;
+    virtual bool IsDesktopOrDock () = 0;
+
+    virtual bool IsSkipTaskbarOrPager () = 0;
+    virtual bool IsHidden () = 0;
+    virtual bool IsInShowdesktopMode () = 0;
+    virtual bool IsShaded () = 0;
+
+    virtual bool IsMinimized () = 0;
+
+    virtual void DoOverrideFrameRegion (CompRegion &) = 0;
+
+    virtual void DoHide () = 0;
+    virtual void DoNotifyHidden () = 0;
+    virtual void DoShow () = 0;
+    virtual void DoNotifyShown () = 0;
+
+    virtual void DoMoveFocusAway () = 0;
+    virtual PostPaintAction DoHandleAnimations (unsigned int ms) = 0;
+    virtual void DoAddDamage () = 0;
+
+    virtual void DoDeleteHandler () = 0;
+
+    virtual unsigned int GetNoCoreInstanceMask () = 0;
+
+    virtual compiz::WindowInputRemoverInterface::Ptr GetInputRemover () = 0;
+};
+
+class UnityShowdesktopHandler
+{
+ public:
+
+  UnityShowdesktopHandler (UnityShowdesktopHandlerWindowInterface *uwi);
+  ~UnityShowdesktopHandler ();
+
+  typedef enum {
+    StateVisible = 0,
+    StateFadeOut = 1,
+    StateFadeIn = 2,
+    StateInvisible = 3
+  } State;
+
+public:
+
+  void FadeOut ();
+  void FadeIn ();
+  UnityShowdesktopHandlerWindowInterface::PostPaintAction Animate (unsigned int ms);
+  void PaintOpacity (unsigned short &opacity);
+  unsigned int GetPaintMask ();
+  void HandleShapeEvent ();
+  void WindowFocusChangeNotify ();
+  void UpdateFrameRegion (CompRegion &r);
+
+  UnityShowdesktopHandler::State GetState ();
+
+  static const unsigned int fade_time;
+  static std::list <UnityShowdesktopHandlerWindowInterface *> animating_windows;
+  static bool ShouldHide (UnityShowdesktopHandlerWindowInterface *);
+  static void InhibitLeaveShowdesktopMode (guint32 xid);
+  static void AllowLeaveShowdesktopMode (guint32 xid);
+  static guint32 InhibitingXid ();
+
+private:
+
+  UnityShowdesktopHandlerWindowInterface *showdesktop_handler_window_interface_;
+  compiz::WindowInputRemoverInterface::Ptr remover_;
+  UnityShowdesktopHandler::State         state_;
+  float                                  progress_;
+  bool                                   was_hidden_;
+  static guint32		         inhibiting_xid;
+};
+
+}
+
+
+#endif

=== modified file 'plugins/unityshell/src/inputremover.cpp'
--- plugins/unityshell/src/inputremover.cpp	2011-09-28 16:25:42 +0000
+++ plugins/unityshell/src/inputremover.cpp	2012-04-02 01:40:26 +0000
@@ -24,6 +24,10 @@
 #include <cstdio>
 #include <cstring>
 
+compiz::WindowInputRemoverInterface::~WindowInputRemoverInterface ()
+{
+}
+
 compiz::WindowInputRemover::WindowInputRemover (Display *dpy,
                                                 Window xid) :
   mDpy (dpy),
@@ -203,7 +207,7 @@
 }
 
 bool
-compiz::WindowInputRemover::save ()
+compiz::WindowInputRemover::saveInput ()
 {
   XRectangle   *rects;
   int          count = 0, ordering;
@@ -267,7 +271,7 @@
 }
 
 bool
-compiz::WindowInputRemover::remove ()
+compiz::WindowInputRemover::removeInput ()
 {
   if (!mNInputRects)
     if (!save ())
@@ -290,7 +294,7 @@
 }
 
 bool
-compiz::WindowInputRemover::restore ()
+compiz::WindowInputRemover::restoreInput ()
 {
   XShapeSelectInput (mDpy, mShapeWindow, NoEventMask);
 

=== modified file 'plugins/unityshell/src/inputremover.h'
--- plugins/unityshell/src/inputremover.h	2011-09-13 12:52:31 +0000
+++ plugins/unityshell/src/inputremover.h	2012-04-02 01:40:26 +0000
@@ -22,6 +22,8 @@
 #ifndef _COMPIZ_INPUTREMOVER_H
 #define _COMPIZ_INPUTREMOVER_H
 
+#include <memory>
+
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/shape.h>
@@ -29,19 +31,39 @@
 // Will be merged back into compiz
 namespace compiz {
 
-class WindowInputRemover
+class WindowInputRemoverInterface
+{
+  public:
+
+    typedef std::shared_ptr <WindowInputRemoverInterface> Ptr;
+
+    bool save () { return saveInput (); }
+    bool remove () { return removeInput (); }
+    bool restore () { return restoreInput (); }
+
+    virtual ~WindowInputRemoverInterface ();
+
+  protected:
+
+    virtual bool saveInput () = 0;
+    virtual bool removeInput () = 0;
+    virtual bool restoreInput () = 0;
+};
+
+class WindowInputRemover :
+  public WindowInputRemoverInterface
 {
 public:
 
   WindowInputRemover (Display *, Window xid);
   ~WindowInputRemover ();
 
-  bool save ();
-  bool remove ();
-  bool restore ();
-
 private:
 
+  bool saveInput ();
+  bool removeInput ();
+  bool restoreInput ();
+
   void sendShapeNotify ();
 
   Display       *mDpy;

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-03-30 15:24:34 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-04-02 01:40:26 +0000
@@ -904,7 +904,9 @@
 {
   for (CompWindow *w : screen->windows ())
   {
-    if (UnityShowdesktopHandler::shouldHide (w))
+    UnityWindow *uw = UnityWindow::get (w);
+
+    if (UnityShowdesktopHandler::ShouldHide (static_cast <UnityShowdesktopHandlerWindowInterface *> (uw)))
     {
       UnityWindow::get (w)->enterShowDesktop ();
       // the animation plugin does strange things here ...
@@ -941,16 +943,16 @@
   /* Where a window is inhibiting, only allow the window
    * that is inhibiting the leave show desktop to actually
    * fade in again - all other windows should remain faded out */
-  if (!UnityShowdesktopHandler::inhibitingXid ())
+  if (!UnityShowdesktopHandler::InhibitingXid ())
   {
     for (CompWindow *cw : screen->windows ())
     {
       if (cw->inShowDesktopMode ())
       {
-	UnityWindow::get (cw)->leaveShowDesktop ();
-	// the animation plugin does strange things here ...
-	// if this notification is sent
-	//cw->windowNotify (CompWindowNotifyLeaveShowDesktopMode);
+        UnityWindow::get (cw)->leaveShowDesktop ();
+        // the animation plugin does strange things here ...
+        // if this notification is sent
+        //cw->windowNotify (CompWindowNotifyLeaveShowDesktopMode);
       }
     }
 
@@ -960,12 +962,12 @@
   }
   else
   {
-    CompWindow *cw = screen->findWindow (UnityShowdesktopHandler::inhibitingXid ());
+    CompWindow *cw = screen->findWindow (UnityShowdesktopHandler::InhibitingXid ());
     if (cw)
     {
       if (cw->inShowDesktopMode ())
       {
-	UnityWindow::get (cw)->leaveShowDesktop ();
+        UnityWindow::get (cw)->leaveShowDesktop ();
       }
     }
   }
@@ -974,227 +976,159 @@
 void UnityWindow::enterShowDesktop ()
 {
   if (!mShowdesktopHandler)
-    mShowdesktopHandler = new UnityShowdesktopHandler (window);
+    mShowdesktopHandler = new UnityShowdesktopHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (this));
 
   window->setShowDesktopMode (true);
-  mShowdesktopHandler->fadeOut ();
+  mShowdesktopHandler->FadeOut ();
 }
 
 void UnityWindow::leaveShowDesktop ()
 {
   if (mShowdesktopHandler)
   {
-    mShowdesktopHandler->fadeIn ();
+    mShowdesktopHandler->FadeIn ();
     window->setShowDesktopMode (false);
-    delete mShowdesktopHandler;
-    mShowdesktopHandler = NULL;
   }
 }
 
 void UnityWindow::activate ()
 {
-  UnityShowdesktopHandler::inhibitLeaveShowdesktopMode (window->id ());
+  UnityShowdesktopHandler::InhibitLeaveShowdesktopMode (window->id ());
   window->activate ();
-  UnityShowdesktopHandler::allowLeaveShowdesktopMode (window->id ());
-}
-
-bool UnityWindow::handleAnimations (unsigned int ms)
-{
+  UnityShowdesktopHandler::AllowLeaveShowdesktopMode (window->id ());
+}
+
+void UnityWindow::DoEnableFocus ()
+{
+  window->focusSetEnabled (this, true);
+}
+
+void UnityWindow::DoDisableFocus ()
+{
+  window->focusSetEnabled (this, false);
+}
+
+bool UnityWindow::IsOverrideRedirect ()
+{
+  return window->overrideRedirect ();
+}
+
+bool UnityWindow::IsManaged ()
+{
+  return window->managed ();
+}
+
+bool UnityWindow::IsGrabbed ()
+{
+  return window->grabbed ();
+}
+
+bool UnityWindow::IsDesktopOrDock ()
+{
+  return (window->type () & (CompWindowTypeDesktopMask | CompWindowTypeDockMask));
+}
+
+bool UnityWindow::IsSkipTaskbarOrPager ()
+{
+  return (window->state () & (CompWindowStateSkipTaskbarMask | CompWindowStateSkipPagerMask));
+}
+
+bool UnityWindow::IsInShowdesktopMode ()
+{
+  return window->inShowDesktopMode ();
+}
+
+bool UnityWindow::IsHidden ()
+{
+  return window->state () & CompWindowStateHiddenMask;
+}
+
+bool UnityWindow::IsShaded ()
+{
+  return window->shaded ();
+}
+
+bool UnityWindow::IsMinimized ()
+{
+  return window->minimized ();
+}
+
+void UnityWindow::DoOverrideFrameRegion (CompRegion &region)
+{
+  unsigned int oldUpdateFrameRegionIndex = window->updateFrameRegionGetCurrentIndex ();
+
+  window->updateFrameRegionSetCurrentIndex (MAXSHORT);
+  window->updateFrameRegion (region);
+  window->updateFrameRegionSetCurrentIndex (oldUpdateFrameRegionIndex);
+}
+
+void UnityWindow::DoHide ()
+{
+  window->changeState (window->state () | CompWindowStateHiddenMask);
+}
+
+void UnityWindow::DoNotifyHidden ()
+{
+  window->windowNotify (CompWindowNotifyHide);
+}
+
+void UnityWindow::DoShow ()
+{
+  window->changeState (window->state () & ~(CompWindowStateHiddenMask));
+}
+
+void UnityWindow::DoNotifyShown ()
+{
+  window->windowNotify (CompWindowNotifyShow);
+}
+
+void UnityWindow::DoMoveFocusAway ()
+{
+  window->moveInputFocusToOtherWindow ();
+}
+
+UnityShowdesktopHandlerWindowInterface::PostPaintAction UnityWindow::DoHandleAnimations (unsigned int ms)
+{
+  UnityShowdesktopHandlerWindowInterface::PostPaintAction action = UnityShowdesktopHandlerWindowInterface::PostPaintAction::Wait;
+
   if (mShowdesktopHandler)
-    if (mShowdesktopHandler->animate (ms))
-    {
-      delete mShowdesktopHandler;
-      mShowdesktopHandler = NULL;
-      return true;
-    }
-
-  return false;
-}
-
-/* 300 ms */
-const unsigned int UnityShowdesktopHandler::fade_time = 300;
-CompWindowList UnityShowdesktopHandler::animating_windows (0);
-
-bool UnityShowdesktopHandler::shouldHide (CompWindow *w)
-{
-  if (w->overrideRedirect ())
-    return false;
-
-  if (!w->managed ())
-    return false;
-
-  if (w->grabbed ())
-    return false;
-
-  if (w->wmType () & (CompWindowTypeDesktopMask |
-                      CompWindowTypeDockMask))
-   return false;
-
-  if (w->state () & (CompWindowStateSkipPagerMask |
-         CompWindowStateSkipTaskbarMask))
-    return false;
-
-  if ((w->state () & CompWindowStateHiddenMask))
-    if (!(w->inShowDesktopMode () || w->shaded ()))
-      return false;
-
-  return true;
-}
-
-guint32 UnityShowdesktopHandler::mInhibitingXid = 0;
-
-void
-UnityShowdesktopHandler::inhibitLeaveShowdesktopMode (guint32 xid)
-{
-  if (!mInhibitingXid)
-    mInhibitingXid = xid;
-}
-
-void
-UnityShowdesktopHandler::allowLeaveShowdesktopMode (guint32 xid)
-{
-  if (mInhibitingXid == xid)
-    mInhibitingXid = 0;
-}
-
-guint32
-UnityShowdesktopHandler::inhibitingXid ()
-{
-  return mInhibitingXid;
-}
-
-UnityShowdesktopHandler::UnityShowdesktopHandler (CompWindow *w) :
-  mWindow (w),
-  mRemover (new compiz::WindowInputRemover (screen->dpy (), w->id ())),
-  mState (Visible),
-  mProgress (0.0f)
-{
-}
-
-UnityShowdesktopHandler::~UnityShowdesktopHandler ()
-{
-  if (mRemover)
-    delete mRemover;
-}
-
-void UnityShowdesktopHandler::fadeOut ()
-{
-  mState = UnityShowdesktopHandler::FadeOut;
-  mProgress = 1.0f;
-
-  mWasHidden = mWindow->state () & CompWindowStateHiddenMask;
-
-  if (!mWasHidden)
-  {
-    mWindow->changeState (mWindow->state () | CompWindowStateHiddenMask);
-    mWindow->windowNotify (CompWindowNotifyHide);
-    mRemover->save ();
-    mRemover->remove ();
-  }
-
-  CompositeWindow::get (mWindow)->addDamage ();
-
-  if (std::find (animating_windows.begin(),
-                 animating_windows.end(),
-                 mWindow) == animating_windows.end())
-    animating_windows.push_back(mWindow);
-}
-
-void UnityShowdesktopHandler::fadeIn ()
-{
-  mState = UnityShowdesktopHandler::FadeIn;
-
-  if (!mWasHidden)
-  {
-    mWindow->changeState (mWindow->state () & ~CompWindowStateHiddenMask);
-    mWindow->windowNotify (CompWindowNotifyShow);
-    mRemover->restore ();
-  }
-
-  CompositeWindow::get (mWindow)->addDamage ();
-}
-
-bool UnityShowdesktopHandler::animate (unsigned int ms)
-{
-  float inc = fade_time / (float) ms;
-
-  if (mState == UnityShowdesktopHandler::FadeOut)
-  {
-    mProgress -= inc;
-    if (mProgress <= 0.0f)
-    {
-      mProgress = 0.0f;
-      mState = Invisible;
-    }
-    else
-      CompositeWindow::get (mWindow)->addDamage ();
-  }
-  else if (mState == FadeIn)
-  {
-    mProgress += inc;
-    if (mProgress >= 1.0f)
-    {
-      mProgress = 1.0f;
-      mState = Visible;
-
-      return true;
-    }
-    else
-      CompositeWindow::get (mWindow)->addDamage ();
-  }
-
-  return false;
-}
-
-void UnityShowdesktopHandler::paintAttrib (GLWindowPaintAttrib &attrib)
-{
-  attrib.opacity = static_cast <int> (static_cast <float> (attrib.opacity) * mProgress);
-}
-
-unsigned int UnityShowdesktopHandler::getPaintMask ()
-{
-    return 0;
-}
-
-void UnityShowdesktopHandler::handleEvent (XEvent *event)
-{
-  /* Ignore sent events from the InputRemover */
-  if (screen->XShape () && event->type ==
-      screen->shapeEvent () + ShapeNotify &&
+    action = mShowdesktopHandler->Animate (ms);
+
+  return action;
+}
+
+void UnityWindow::DoAddDamage ()
+{
+  cWindow->addDamage ();
+}
+
+void UnityWindow::DoDeleteHandler ()
+{
+  delete mShowdesktopHandler;
+  mShowdesktopHandler = NULL;
+}
+
+compiz::WindowInputRemoverInterface::Ptr
+UnityWindow::GetInputRemover ()
+{
+  return compiz::WindowInputRemoverInterface::Ptr (new compiz::WindowInputRemover (screen->dpy (), window->id ()));
+}
+
+unsigned int
+UnityWindow::GetNoCoreInstanceMask ()
+{
+  return PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
+}
+
+void UnityWindow::handleEvent (XEvent *event)
+{
+  if (screen->XShape () &&
+      event->type == screen->shapeEvent () + ShapeNotify &&
       !event->xany.send_event)
   {
-    if (mRemover)
-    {
-      mRemover->save ();
-      mRemover->remove ();
-    }
-  }
-}
-
-void UnityShowdesktopHandler::windowNotify (CompWindowNotify n)
-{
-  if (n == CompWindowNotifyFocusChange && mWindow->minimized ())
-  {
-    for (CompWindow *w : animating_windows)
-      w->focusSetEnabled (UnityWindow::get (w), false);
-
-    mWindow->moveInputFocusToOtherWindow ();
-
-    for (CompWindow *w : animating_windows)
-      w->focusSetEnabled (UnityWindow::get (w), true);
-  }
-}
-
-void UnityShowdesktopHandler::updateFrameRegion (CompRegion &r)
-{
-  unsigned int oldUpdateFrameRegionIndex;
-  r = CompRegion ();
-
-  /* Ensure no other plugins can touch this frame region */
-  oldUpdateFrameRegionIndex = mWindow->updateFrameRegionGetCurrentIndex ();
-  mWindow->updateFrameRegionSetCurrentIndex (MAXSHORT);
-  mWindow->updateFrameRegion (r);
-  mWindow->updateFrameRegionSetCurrentIndex (oldUpdateFrameRegionIndex);
+    if (mShowdesktopHandler)
+      mShowdesktopHandler->HandleShapeEvent ();
+  }
 }
 
 /* called whenever we need to repaint parts of the screen */
@@ -1275,16 +1209,10 @@
 
 void UnityScreen::preparePaint(int ms)
 {
-  CompWindowList remove_windows;
-
   cScreen->preparePaint(ms);
 
-  for (CompWindow *w : UnityShowdesktopHandler::animating_windows)
-    if (UnityWindow::get (w)->handleAnimations (ms))
-      remove_windows.push_back(w);
-
-  for (CompWindow *w : remove_windows)
-    UnityShowdesktopHandler::animating_windows.remove (w);
+  for (UnityShowdesktopHandlerWindowInterface *wi : UnityShowdesktopHandler::animating_windows)
+    wi->HandleAnimations (ms);
 
   if (damaged)
   {
@@ -1294,6 +1222,28 @@
 
 }
 
+void UnityScreen::donePaint()
+{
+  std::list <UnityShowdesktopHandlerWindowInterface *> remove_windows;
+
+  for (UnityShowdesktopHandlerWindowInterface *wi : UnityShowdesktopHandler::animating_windows)
+  {
+    UnityShowdesktopHandlerWindowInterface::PostPaintAction action = wi->HandleAnimations (0);
+    if (action == UnityShowdesktopHandlerWindowInterface::PostPaintAction::Remove)
+      remove_windows.push_back(wi);
+    else if (action == UnityShowdesktopHandlerWindowInterface::PostPaintAction::Damage)
+      wi->AddDamage ();
+  }
+
+  for (UnityShowdesktopHandlerWindowInterface *wi : remove_windows)
+  {
+    wi->DeleteHandler ();
+    UnityShowdesktopHandler::animating_windows.remove (wi);
+  }
+
+  cScreen->donePaint ();
+}
+
 /* Grab changed nux regions and add damage rects for them */
 void UnityScreen::damageNuxRegions()
 {
@@ -1429,7 +1379,7 @@
       break;
     }
     case MapRequest:
-      UnityShowdesktopHandler::inhibitLeaveShowdesktopMode (event->xmaprequest.window);
+      UnityShowdesktopHandler::InhibitLeaveShowdesktopMode (event->xmaprequest.window);
       break;
     default:
         if (screen->shapeEvent () + ShapeNotify == event->type)
@@ -1441,8 +1391,7 @@
           {
             UnityWindow *uw = UnityWindow::get (w);
 
-            if (uw->mShowdesktopHandler)
-              uw->mShowdesktopHandler->handleEvent(event);
+            uw->handleEvent(event);
           }
         }
       break;
@@ -1463,7 +1412,7 @@
       }
       break;
     case MapRequest:
-      UnityShowdesktopHandler::allowLeaveShowdesktopMode (event->xmaprequest.window);
+      UnityShowdesktopHandler::AllowLeaveShowdesktopMode (event->xmaprequest.window);
       break;
   }
 
@@ -2149,8 +2098,8 @@
   }
   else if (mShowdesktopHandler)
   {
-    mShowdesktopHandler->paintAttrib (wAttrib);
-    mask |= mShowdesktopHandler->getPaintMask ();
+    mShowdesktopHandler->PaintOpacity (wAttrib.opacity);
+    mask |= mShowdesktopHandler->GetPaintMask ();
   }
 
   if (uScreen->panel_controller_->GetTrayXid () == window->id () && !uScreen->allowWindowPaint)
@@ -2280,7 +2229,7 @@
 }
 
 bool
-UnityWindow::minimized ()
+UnityWindow::Minimized ()
 {
   return mMinimizeHandler.get () != nullptr;
 }
@@ -2354,7 +2303,8 @@
   }
   else if (mShowdesktopHandler)
   {
-    mShowdesktopHandler->windowNotify (n);
+    if (n == CompWindowNotifyFocusChange)
+      mShowdesktopHandler->WindowFocusChangeNotify ();
   }
 
   // We do this after the notify to ensure input focus has actually been moved.
@@ -2393,7 +2343,7 @@
   if (mMinimizeHandler)
     mMinimizeHandler->updateFrameRegion (region);
   else if (mShowdesktopHandler)
-    mShowdesktopHandler->updateFrameRegion (region);
+    mShowdesktopHandler->UpdateFrameRegion (region);
   else
     window->updateFrameRegion (region);
 }
@@ -2933,7 +2883,7 @@
       window->minimize ();
   }
 
-  UnityShowdesktopHandler::animating_windows.remove (window);
+  UnityShowdesktopHandler::animating_windows.remove (static_cast <UnityShowdesktopHandlerWindowInterface *> (this));
 
   if (mShowdesktopHandler)
     delete mShowdesktopHandler;

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-03-30 04:00:05 +0000
+++ plugins/unityshell/src/unityshell.h	2012-04-02 01:40:26 +0000
@@ -50,6 +50,7 @@
 #include "SwitcherController.h"
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
+#include "UnityShowdesktopHandler.h"
 #ifndef USE_GLES
 #include "ScreenEffectFramebufferObject.h"
 #endif
@@ -64,51 +65,6 @@
 namespace unity
 {
 
-class UnityShowdesktopHandler
-{
- public:
-
-  UnityShowdesktopHandler (CompWindow *w);
-  ~UnityShowdesktopHandler ();
-
-  typedef enum {
-    Visible = 0,
-    FadeOut = 1,
-    FadeIn = 2,
-    Invisible = 3
-  } State;
-
-public:
-
-  void fadeOut ();
-  void fadeIn ();
-  bool animate (unsigned int ms);
-  void paintAttrib (GLWindowPaintAttrib &attrib);
-  unsigned int getPaintMask ();
-  void handleEvent (XEvent *);
-  void windowNotify (CompWindowNotify n);
-  void updateFrameRegion (CompRegion &r);
-
-  UnityShowdesktopHandler::State state ();
-
-  static const unsigned int fade_time;
-  static CompWindowList     animating_windows;
-  static bool shouldHide (CompWindow *);
-  static void inhibitLeaveShowdesktopMode (guint32 xid);
-  static void allowLeaveShowdesktopMode (guint32 xid);
-  static guint32 inhibitingXid ();
-
-private:
-
-  CompWindow                     *mWindow;
-  compiz::WindowInputRemover     *mRemover;
-  UnityShowdesktopHandler::State mState;
-  float                          mProgress;
-  bool                           mWasHidden;
-  static guint32		 mInhibitingXid;
-};
-
-
 /* base screen class */
 class UnityScreen :
   public unity::debug::Introspectable,
@@ -145,6 +101,7 @@
 
   void preparePaint (int ms);
   void paintFboForOutput (CompOutput *output);
+  void donePaint ();
 
   void RaiseInputWindows();
 
@@ -351,6 +308,7 @@
 class UnityWindow :
   public WindowInterface,
   public GLWindowInterface,
+  public UnityShowdesktopHandlerWindowInterface,
   public BaseSwitchWindow,
   public PluginClassHandler <UnityWindow, CompWindow>
 {
@@ -365,7 +323,7 @@
 
   void minimize ();
   void unminimize ();
-  bool minimized ();
+  bool Minimized ();
   bool focus ();
   void activate ();
 
@@ -407,7 +365,9 @@
 
   void enterShowDesktop ();
   void leaveShowDesktop ();
-  bool handleAnimations (unsigned int ms);
+  bool HandleAnimations (unsigned int ms);
+
+  void handleEvent (XEvent *event);
 
   typedef compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>
           UnityMinimizedHandler;
@@ -419,6 +379,36 @@
 
   guint  focusdesktop_handle_;
   static gboolean FocusDesktopTimeout(gpointer data);
+
+  void DoEnableFocus ();
+  void DoDisableFocus ();
+
+  bool IsOverrideRedirect ();
+  bool IsManaged ();
+  bool IsGrabbed ();
+  bool IsDesktopOrDock ();
+  bool IsSkipTaskbarOrPager ();
+  bool IsHidden ();
+  bool IsInShowdesktopMode ();
+  bool IsShaded ();
+  bool IsMinimized ();
+  void DoOverrideFrameRegion (CompRegion &r);
+
+  void DoHide ();
+  void DoNotifyHidden ();
+  void DoShow ();
+  void DoNotifyShown ();
+
+  void DoAddDamage ();
+  UnityShowdesktopHandlerWindowInterface::PostPaintAction DoHandleAnimations (unsigned int ms);
+
+  void DoMoveFocusAway ();
+
+  void DoDeleteHandler ();
+
+  unsigned int GetNoCoreInstanceMask ();
+
+  compiz::WindowInputRemoverInterface::Ptr GetInputRemover ();
 };
 
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-03-31 10:47:22 +0000
+++ tests/CMakeLists.txt	2012-04-02 01:40:26 +0000
@@ -33,7 +33,7 @@
      )
 add_definitions (${CFLAGS})
 
-set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION} -lm")
+set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION} -lcompiz_core -lm")
 link_libraries (${LIBS})
 
 set (LIB_PATHS ${TEST_UNIT_DEPS_LIBRARY_DIRS})
@@ -140,6 +140,8 @@
                  test_main_xless.cpp
                  test_grabhandle.cpp
                  test_unityshell_private.cpp
+                 test_lensview_impl.cpp
+		 test_showdesktop_handler.cpp
                  ${UNITY_SRC}/AbstractLauncherIcon.cpp
                  ${UNITY_SRC}/AbstractShortcutHint.h
                  ${UNITY_SRC}/Animator.cpp
@@ -160,6 +162,7 @@
                  ${UNITY_SRC}/Timer.cpp
                  ${UNITY_SRC}/UnityshellPrivate.cpp
                  ${UNITY_SRC}/WindowManager.cpp
+		 ${UNITY_SRC}/UnityShowdesktopHandler.cpp
                  ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle.cpp
                  ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-group.cpp
                  ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-impl-factory.cpp

=== added file 'tests/test_showdesktop_handler.cpp'
--- tests/test_showdesktop_handler.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_showdesktop_handler.cpp	2012-04-02 01:40:26 +0000
@@ -0,0 +1,539 @@
+#include <list>
+#include <algorithm>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <UnityShowdesktopHandler.h>
+
+using namespace unity;
+using ::testing::_;
+using ::testing::Return;
+using ::testing::Invoke;
+using ::testing::InSequence;
+
+compiz::WindowInputRemoverInterface::~WindowInputRemoverInterface () {}
+
+class MockWindowInputRemover :
+  public compiz::WindowInputRemoverInterface
+{
+  public:
+
+    MockWindowInputRemover ()
+    {
+      ON_CALL (*this, saveInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, removeInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, restoreInput ()).WillByDefault (Return (true));
+    }
+
+    MOCK_METHOD0 (saveInput, bool ());
+    MOCK_METHOD0 (removeInput, bool ());
+    MOCK_METHOD0 (restoreInput, bool ());
+};
+
+class UnityShowdesktopHandlerTest :
+  public ::testing::Test
+{
+public:
+
+  ~UnityShowdesktopHandlerTest ()
+  {
+    UnityShowdesktopHandler::animating_windows.clear ();
+  }
+
+  template <class T, class U> static typename T::Ptr makeShared () { return typename T::Ptr (new U); }
+
+};
+
+
+class MockUnityShowdesktopHandlerWindow :
+  public UnityShowdesktopHandlerWindowInterface
+{
+  public:
+
+    MockUnityShowdesktopHandlerWindow ()
+    {
+      ON_CALL (*this, IsOverrideRedirect ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsManaged ()).WillByDefault (Return (true));
+      ON_CALL (*this, IsGrabbed ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsDesktopOrDock ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsSkipTaskbarOrPager ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsHidden ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsInShowdesktopMode ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsShaded ()).WillByDefault (Return (false));
+      ON_CALL (*this, IsMinimized ()).WillByDefault (Return (false));
+
+      ON_CALL (*this, DoHandleAnimations (_)).WillByDefault (Return (UnityShowdesktopHandlerWindowInterface::PostPaintAction::Damage));
+      ON_CALL (*this, GetNoCoreInstanceMask ()).WillByDefault (Return (1));
+      ON_CALL (*this, GetInputRemover ()).WillByDefault (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemover>));
+    }
+
+    MOCK_METHOD0 (DoEnableFocus, void ());
+    MOCK_METHOD0 (DoDisableFocus, void ());
+    MOCK_METHOD0 (IsOverrideRedirect, bool ());
+    MOCK_METHOD0 (IsManaged, bool ());
+    MOCK_METHOD0 (IsGrabbed, bool ());
+    MOCK_METHOD0 (IsDesktopOrDock, bool ());
+    MOCK_METHOD0 (IsSkipTaskbarOrPager, bool ());
+    MOCK_METHOD0 (IsHidden, bool ());
+    MOCK_METHOD0 (IsInShowdesktopMode, bool ());
+    MOCK_METHOD0 (IsShaded, bool ());
+    MOCK_METHOD0 (IsMinimized, bool ());
+    MOCK_METHOD1 (DoOverrideFrameRegion, void (CompRegion &));
+    MOCK_METHOD0 (DoHide, void ());
+    MOCK_METHOD0 (DoNotifyHidden, void ());
+    MOCK_METHOD0 (DoShow, void ());
+    MOCK_METHOD0 (DoNotifyShown, void ());
+    MOCK_METHOD0 (DoMoveFocusAway, void ());
+    MOCK_METHOD1 (DoHandleAnimations, UnityShowdesktopHandlerWindowInterface::PostPaintAction (unsigned int));
+    MOCK_METHOD0 (DoAddDamage, void ());
+    MOCK_METHOD0 (GetNoCoreInstanceMask, unsigned int ());
+    MOCK_METHOD0 (GetInputRemover, compiz::WindowInputRemoverInterface::Ptr ());
+    MOCK_METHOD0 (DoDeleteHandler, void ());
+};
+
+TEST_F(UnityShowdesktopHandlerTest, TestNoORWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestNoUnmanagedWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ()).WillOnce (Return (false));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestNoGrabbedWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestNoDesktopOrDockWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ());
+  EXPECT_CALL (mMockWindow, IsDesktopOrDock ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestNoSkipTaskbarOrPagerWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ());
+  EXPECT_CALL (mMockWindow, IsDesktopOrDock ());
+  EXPECT_CALL (mMockWindow, IsSkipTaskbarOrPager ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestHiddenNotSDAndShadedWindowsNoSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ());
+  EXPECT_CALL (mMockWindow, IsDesktopOrDock ());
+  EXPECT_CALL (mMockWindow, IsSkipTaskbarOrPager ());
+  EXPECT_CALL (mMockWindow, IsHidden ()).WillOnce (Return (true));
+  EXPECT_CALL (mMockWindow, IsInShowdesktopMode ()).WillOnce (Return (false));
+  EXPECT_CALL (mMockWindow, IsShaded ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestHiddenSDAndShadedWindowsNoSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ());
+  EXPECT_CALL (mMockWindow, IsDesktopOrDock ());
+  EXPECT_CALL (mMockWindow, IsSkipTaskbarOrPager ());
+  EXPECT_CALL (mMockWindow, IsHidden ()).WillOnce (Return (true));
+  EXPECT_CALL (mMockWindow, IsInShowdesktopMode ()).WillOnce (Return (true));
+  EXPECT_FALSE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestHiddenNotSDAndNotShadedWindowsSD)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ());
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
+  EXPECT_CALL (mMockWindow, IsManaged ());
+  EXPECT_CALL (mMockWindow, IsGrabbed ());
+  EXPECT_CALL (mMockWindow, IsDesktopOrDock ());
+  EXPECT_CALL (mMockWindow, IsSkipTaskbarOrPager ());
+  EXPECT_CALL (mMockWindow, IsHidden ()).WillOnce (Return (true));
+  EXPECT_CALL (mMockWindow, IsInShowdesktopMode ()).WillOnce (Return (false));
+  EXPECT_CALL (mMockWindow, IsShaded ()).WillOnce (Return (false));
+  EXPECT_TRUE (UnityShowdesktopHandler::ShouldHide (&mMockWindow));
+}
+
+class MockWindowInputRemoverTestFadeOut :
+  public compiz::WindowInputRemoverInterface
+{
+  public:
+
+    MockWindowInputRemoverTestFadeOut ()
+    {
+      ON_CALL (*this, saveInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, removeInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, restoreInput ()).WillByDefault (Return (true));
+
+      EXPECT_CALL (*this, saveInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, removeInput ()).WillOnce (Return (true));
+    }
+
+    MOCK_METHOD0 (saveInput, bool ());
+    MOCK_METHOD0 (removeInput, bool ());
+    MOCK_METHOD0 (restoreInput, bool ());
+};
+
+TEST_F(UnityShowdesktopHandlerTest, TestFadeOutHidesWindow)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOut>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+class MockWindowInputRemoverTestFadeOutAlready :
+  public compiz::WindowInputRemoverInterface
+{
+  public:
+
+    MockWindowInputRemoverTestFadeOutAlready ()
+    {
+      ON_CALL (*this, saveInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, removeInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, restoreInput ()).WillByDefault (Return (true));
+    }
+
+    MOCK_METHOD0 (saveInput, bool ());
+    MOCK_METHOD0 (removeInput, bool ());
+    MOCK_METHOD0 (restoreInput, bool ());
+};
+
+TEST_F(UnityShowdesktopHandlerTest, TestFadeOutOnHiddenDoesntHideWindow)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutAlready>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ()).WillOnce (Return (true));
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 0);
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestFadeOutAlreadyFadedDoesntHideWindow)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOut>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+  mMockHandler.FadeOut ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestFadeInNonFadedDoesntShowWindow)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutAlready>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  mMockHandler.FadeIn ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 0);
+}
+
+class MockWindowInputRemoverTestFadeOutFadeIn :
+  public compiz::WindowInputRemoverInterface
+{
+  public:
+
+    MockWindowInputRemoverTestFadeOutFadeIn ()
+    {
+      ON_CALL (*this, saveInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, removeInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, restoreInput ()).WillByDefault (Return (true));
+
+      EXPECT_CALL (*this, saveInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, removeInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, restoreInput ()).WillOnce (Return (true));
+    }
+
+    MOCK_METHOD0 (saveInput, bool ());
+    MOCK_METHOD0 (removeInput, bool ());
+    MOCK_METHOD0 (restoreInput, bool ());
+};
+
+TEST_F(UnityShowdesktopHandlerTest, TestFadeOutHidesWindowFadeInShowsWindow)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutFadeIn>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_CALL (mMockWindow, DoShow ());
+  EXPECT_CALL (mMockWindow, DoNotifyShown ());
+
+  mMockHandler.FadeIn ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestAnimationPostPaintActions)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutFadeIn>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_CALL (mMockWindow, DoShow ());
+  EXPECT_CALL (mMockWindow, DoNotifyShown ());
+
+  for (unsigned int i = 0; i < UnityShowdesktopHandler::fade_time; i++)
+  {
+    UnityShowdesktopHandlerWindowInterface::PostPaintAction action = mMockHandler.Animate (1);
+
+    if (i == 300)
+      EXPECT_EQ (action, UnityShowdesktopHandlerWindowInterface::PostPaintAction::Wait);
+    else
+      EXPECT_EQ (action, UnityShowdesktopHandlerWindowInterface::PostPaintAction::Damage);
+  }
+
+  mMockHandler.FadeIn ();
+
+  for (unsigned int i = 0; i < UnityShowdesktopHandler::fade_time; i++)
+  {
+    UnityShowdesktopHandlerWindowInterface::PostPaintAction action = mMockHandler.Animate (1);
+
+    if (i == 300)
+      EXPECT_EQ (action, UnityShowdesktopHandlerWindowInterface::PostPaintAction::Remove);
+    else
+      EXPECT_EQ (action, UnityShowdesktopHandlerWindowInterface::PostPaintAction::Damage);
+  }
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestAnimationOpacity)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutFadeIn>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_CALL (mMockWindow, DoShow ());
+  EXPECT_CALL (mMockWindow, DoNotifyShown ());
+
+  /* The funny expectations here are to account for rounding errors that would
+   * otherwise make testing the code painful */
+
+  for (unsigned int i = 0; i < UnityShowdesktopHandler::fade_time; i++)
+  {
+    unsigned short opacity = std::numeric_limits <unsigned short>::max ();
+    mMockHandler.PaintOpacity (opacity);
+
+    mMockHandler.Animate (1);
+
+    if (i == 300)
+      EXPECT_EQ (opacity, std::numeric_limits <unsigned short>::max ());
+    else
+    {
+      float rem = opacity - std::numeric_limits <unsigned short>::max () * (1.0f - i / static_cast <float> (UnityShowdesktopHandler::fade_time));
+      EXPECT_TRUE (rem <= 1.0f && rem >= -1.0f);
+    }
+  }
+
+  mMockHandler.FadeIn ();
+
+  for (unsigned int i = 0; i < UnityShowdesktopHandler::fade_time; i++)
+  {
+    unsigned short opacity = std::numeric_limits <unsigned short>::max ();
+    mMockHandler.PaintOpacity (opacity);
+
+    mMockHandler.Animate (1);
+
+    if (i == 300)
+      EXPECT_EQ (opacity, std::numeric_limits <unsigned short>::max ());
+    else
+    {
+      float rem = opacity - std::numeric_limits <unsigned short>::max () * (i / static_cast <float> (UnityShowdesktopHandler::fade_time));
+      EXPECT_TRUE (rem <= 1.0f && rem >= -1.0f);
+    }
+  }
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+TEST_F(UnityShowdesktopHandlerTest, TestAnimationPaintMasks)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutFadeIn>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_CALL (mMockWindow, DoShow ());
+  EXPECT_CALL (mMockWindow, DoNotifyShown ());
+  EXPECT_CALL (mMockWindow, GetNoCoreInstanceMask ());
+
+  mMockHandler.Animate (UnityShowdesktopHandler::fade_time);
+
+  EXPECT_EQ (mMockHandler.GetPaintMask (), 1);
+
+  mMockHandler.FadeIn ();
+
+  mMockHandler.Animate (UnityShowdesktopHandler::fade_time);
+
+  EXPECT_EQ (mMockHandler.GetPaintMask (), 0);
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}
+
+class MockWindowInputRemoverTestFadeOutFadeInWithShapeEvent :
+  public compiz::WindowInputRemoverInterface
+{
+  public:
+
+    MockWindowInputRemoverTestFadeOutFadeInWithShapeEvent ()
+    {
+      ON_CALL (*this, saveInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, removeInput ()).WillByDefault (Return (true));
+      ON_CALL (*this, restoreInput ()).WillByDefault (Return (true));
+
+      InSequence s;
+
+      EXPECT_CALL (*this, saveInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, removeInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, saveInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, removeInput ()).WillOnce (Return (true));
+      EXPECT_CALL (*this, restoreInput ()).WillOnce (Return (true));
+    }
+
+    MOCK_METHOD0 (saveInput, bool ());
+    MOCK_METHOD0 (removeInput, bool ());
+    MOCK_METHOD0 (restoreInput, bool ());
+};
+
+TEST_F(UnityShowdesktopHandlerTest, TestShapeEvent)
+{
+  MockUnityShowdesktopHandlerWindow mMockWindow;
+
+  EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::makeShared<compiz::WindowInputRemoverInterface, MockWindowInputRemoverTestFadeOutFadeInWithShapeEvent>));
+
+  UnityShowdesktopHandler mMockHandler (static_cast <UnityShowdesktopHandlerWindowInterface *> (&mMockWindow));
+
+  EXPECT_CALL (mMockWindow, IsHidden ());
+  EXPECT_CALL (mMockWindow, DoHide ());
+  EXPECT_CALL (mMockWindow, DoNotifyHidden ());
+
+  mMockHandler.FadeOut ();
+
+  EXPECT_CALL (mMockWindow, DoShow ());
+  EXPECT_CALL (mMockWindow, DoNotifyShown ());
+
+  mMockHandler.HandleShapeEvent ();
+
+  mMockHandler.FadeIn ();
+
+  EXPECT_EQ (UnityShowdesktopHandler::animating_windows.size (), 1);
+}