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

[Sam Spilsbury]

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_/

=== 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-03-30 15:35:31 +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-03-30 15:35:31 +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-03-30 15:35:31 +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-03-30 15:35:31 +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 04:00:05 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-03-30 15:35:31 +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-03-30 15:35:31 +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-29 20:25:35 +0000
+++ tests/CMakeLists.txt	2012-03-30 15:35:31 +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})
@@ -138,6 +138,11 @@
                  test_main_xless.cpp
                  test_grabhandle.cpp
                  test_unityshell_private.cpp
+<<<<<<< TREE
+=======
+                 test_lensview_impl.cpp
+		 test_showdesktop_handler.cpp
+>>>>>>> MERGE-SOURCE
                  ${UNITY_SRC}/AbstractLauncherIcon.cpp
                  ${UNITY_SRC}/AbstractShortcutHint.h
                  ${UNITY_SRC}/Animator.cpp
@@ -157,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-03-30 15:35:31 +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);
+}