Merge lp:~smspillaz/unity/unity.less-paint-insanity into lp:unity

[Sam Spilsbury]

== Problem ==

The old implementation of ensuring that unity gets painted in the right place and the nux base windows aren't painted was to hook getWindowPaintList and remove nux windows from the list every single time compiz draws a frame.

That resulted in lots of list copying.

In addition, every time we painted a window, we needed to check if it was actually above a nux window by scanning the paint list down, and the complexity of that grew by o(logN) for every new window added.

== Solution ==

Just hook glPaint, skip the wrap chain to core (eg every single plugin skipped) and tell core not to do anything with the window by returning false

== Errata ==

I have no idea why there is a bunch of logic about whether or not to paint the panel in glDraw (that was moved to glPaint). Someone enlighten me?

Blocked by: https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1012956/+merge/110268

== Test ==

Unit tests included, code refactored to get under test

[Sam Spilsbury (smspillaz)]

Bump?

I'd like to see this go in, because it should reduce lots of list copying within unity and also lots of unecessary list traversal, which should represent a nice speed boost. In addition, its far simpler in its implementation and far less bug prone.

I'm sure testing is probably an issue. I'll have another quick look at the code and see if I can think of a way to get it under test.

[Daniel van Vugt (vanvugt)]

Works for me. Though there are some indentation/tab mismatches around line 107. Looks like your tabs are not 8 characters wide like they should be?

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

indentation fixed ... will add tests when I have time.

[Daniel van Vugt (vanvugt)]

Manual testing -> Works well.

This branch also appears to solve the problem of my missing panel shadow when running dev builds of Unity. But that's just a bonus.

review: Approve

[Daniel van Vugt (vanvugt)]

Whoops. It turns out this branch is tricking the decor plugin into painting (proper) shadows for the panel and launcher. It looks awesome so I hope we can keep it. But it's probably a mistake.

[Sam Spilsbury (smspillaz)]

> Whoops. It turns out this branch is tricking the decor plugin into painting
> (proper) shadows for the panel and launcher. It looks awesome so I hope we can
> keep it. But it's probably a mistake.

It probably is, thanks for catching that.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Back, with tests.

The decor plugin is going to try and draw shadows now on the launcher and panel. That's a bug in the decor plugin. See https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1012956/+merge/110268

[Daniel van Vugt (vanvugt)]

Hmm, I was happy with the old proposal. It was so nice and simple. Now I'm seeing lots more green than red, which is not ideal.

I think the implementation is too abstract for its own good. Words like "Requestor", "Interface", "BindingQuery" and "dispatch" confuse what was once simpler code, making maintenance more difficult. Rewriting code to produce something that's harder to understand is much worse than no test cases.

Maybe another day I'll feel more optimistic and test and review it again properly.

[Sam Spilsbury (smspillaz)]

The code is abstract so we can get it under test. More classes with single responsibilities is not a bad thing.

[Daniel van Vugt (vanvugt)]

It shouldn't be a choice between readability and testability. It is possible to write readable code that is testable too.

[Sam Spilsbury (smspillaz)]

The code is readable.

The whole point of coding to interfaces is so that you can clearly label the intent of each particular process that is going on.

For example, I know just from looking at the class names that:

The paint dispatch is responsible for queuing paint requests to the painter
The painter queries whether an fbo was bound to perform a particular operation
Paint Requestors fufill the role of requesting a repaint

That's so much more clear than the voodoocode of how it used to work with stuff like

421 - if (uScreen->doShellRepaint && !uScreen->forcePaintOnTop ())
... PaintDisplay ()

In UnityWindow::glDraw and in UnityWindow::glPaintOutput

If another person comes along and reads that, they now need to figure out what forcePaintOnTop represents, where doShellRepaint is set and unset, why the code is there twice in two different "paint" functions. They also need to figure out where allowWindowPaint is set, why it is set, what it represents, etc.

In addition, there are no tests that the maintainer can go to to see how all the bits fit together. And there is no way for the maintainer to know if they've broken that code.

More Diff Size != Less Maintainability.

[Tim Penhey (thumper)]

Sam,

This code isn't really that readable. The code it is replacing
wasn't really readable either to anyone who doesn't deeply
understand the internals of the compiz drawing machinary.

I do agree that "more diff size != less maintainability", however
in this case, the class names and method names do not express
intent. I am not able to clearly follow what is supposed to be
happening here.

As an example, we have "FBOBindingQueryInterface", which has a
single pure virtual function called "WasBound". However this
method reflects the internal state of some object. It does not
describe the intent, or why a bound FBO is an important thing.

There is no documentation in the header files for any of these
classes compounding their confusion.

I'd suggest that we put all the methods and headers here into a
nested namespace inside unity, as it is directly related to
compiz painting. So unity::compiz or unity::plugin. Givin there
is a ::compiz namespace, it probably makes sense to have it in
namespace unity::plugin.

The constants inside ShellPaintRequestorInterface should really
be an enum. Also it isn't specified that the paint requestors
are supposed to be masks, or that the values will be used as
masks. Also, if we have a nested namespace with an enum, the
enum could be moved outside the class itself.

The fact that I had to do many searchs in the diff to work out
who called what with which parameters is an indicator of how hard
this code is to follow.

On matters of style, this code should follow the unity style
guidelines, not compiz, so * and & next to type not variable
names, no spaces before ().

Also unity has a strong preference for sigc::slot definitions for
functions, not boost::functions.

The fundamental objection I have to this is that the new code and
interfaces don't sufficiently describe the intent, but instead
leak implementation details into the class and method names.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

(cant reply inline)

On "not being able to follow what is happening here" : can you clarify?

On FBOBindingQueryInterface: I will see if this can be removed ... I think it may not be necessary

On namespaces: ack

On enums: I will change the constants to enums if they can be used as masks

On searching the diff: please clarify

On leaking implementation: please clarify (Apart from the fbo query, which I agree is an ugly leak)

Sent from Samsung Mobile

 Tim Penhey <email address hidden> wrote:

Review: Needs Fixing

Sam,

This code isn't really that readable.  The code it is replacing
wasn't really readable either to anyone who doesn't deeply
understand the internals of the compiz drawing machinary.

I do agree that "more diff size != less maintainability", however
in this case, the class names and method names do not express
intent.  I am not able to clearly follow what is supposed to be
happening here.

As an example, we have "FBOBindingQueryInterface", which has a
single pure virtual function called "WasBound".  However this
method reflects the internal state of some object.  It does not
describe the intent, or why a bound FBO is an important thing.

There is no documentation in the header files for any of these
classes compounding their confusion.

I'd suggest that we put all the methods and headers here into a
nested namespace inside unity, as it is directly related to
compiz painting.  So unity::compiz or unity::plugin.  Givin there
is a ::compiz namespace, it probably makes sense to have it in
namespace unity::plugin.

The constants inside ShellPaintRequestorInterface should really
be an enum.  Also it isn't specified that the paint requestors
are supposed to be masks, or that the values will be used as
masks.  Also, if we have a nested namespace with an enum, the
enum could be moved outside the class itself.

The fact that I had to do many searchs in the diff to work out
who called what with which parameters is an indicator of how hard
this code is to follow.

On matters of style, this code should follow the unity style
guidelines, not compiz, so * and & next to type not variable
names, no spaces before ().

Also unity has a strong preference for sigc::slot definitions for
functions, not boost::functions.

The fundamental objection I have to this is that the new code and
interfaces don't sufficiently describe the intent, but instead
leak implementation details into the class and method names.

--
https://code.launchpad.net/~smspillaz/unity/unity.less-paint-insanity/+merge/110267
You are the owner of lp:~smspillaz/unity/unity.less-paint-insanity.

[Sam Spilsbury (smspillaz)]

Leaving this open for now so I can get some more suggestions as to the desired design before I go back in and refactor it.

[Sam Spilsbury (smspillaz)]

Nuked FBOBindingQueryInterface, changed the masks to enum and moved stuff into unity::compiz. Unfortunately that caused ambiguity in namespace lookup so I moved the other stuff in compiz to unity::compiz

[Sam Spilsbury (smspillaz)]

I'm resubmitting this so that it goes to the top again.

I expect this to be marked needs fixing again, but I need some more detailed feedback as to where the design can be improved. I won't merge this fix in without tests.

[Daniel van Vugt (vanvugt)]

As per my previous comments, I think there are a few poor naming decisions here. That coupled with the increase in complexity makes the code much less maintainable than it already is. Despite the test cases.

[Sam Spilsbury (smspillaz)]

> As per my previous comments, I think there are a few poor naming decisions
> here. That coupled with the increase in complexity makes the code much less
> maintainable than it already is. Despite the test cases.

Thanks Daniel, but I need more detailed feedback than that. Preferably some concrete ideas on how I can make the existing code better while still keeping the tests.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:2404
http://s-jenkins:8080/job/unity-ci/3/

review: Disapprove (continuous-integration)

[Martin Mrazik (mrazik)]

The failure above is because of this:
[...]
/home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbuilder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp: In member function ‘bool unity::UnityScreen::WasBound()’:
/home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbuilder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp:741:16: error: ‘class unity::ScreenEffectFramebufferObject’ has no member named ‘NewContentsValid’
/home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbuilder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp:745:1: error: control reaches end of non-void function [-Werror=return-type]
cc1plus: all warnings being treated as errors

It this a problem on jenkins side (build dependencies not 100% up to date)?

[Sam Spilsbury (smspillaz)]

> The failure above is because of this:
> [...]
> /home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbui
> lder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp: In member
> function ‘bool unity::UnityScreen::WasBound()’:
> /home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbui
> lder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp:741:16: error:
> ‘class unity::ScreenEffectFramebufferObject’ has no member named
> ‘NewContentsValid’
> /home/ubuntu/jenkins/workspace/unity-ci/distribution/precise/flavor/amd64/pbui
> lder_setup/work/trunk/plugins/unityshell/src/unityshell.cpp:745:1: error:
> control reaches end of non-void function [-Werror=return-type]
> cc1plus: all warnings being treated as errors
>
> It this a problem on jenkins side (build dependencies not 100% up to date)?

Likely not, probably a typo somewhere. Fixing.

[Sam Spilsbury (smspillaz)]

BTW, Jenkins should put "needs fixing" rather than "disapprove". Disapprove means that you disagree with the whole concept, if it fails CI, it just needs work.

[Martin Mrazik (mrazik)]

> BTW, Jenkins should put "needs fixing" rather than "disapprove". Disapprove
> means that you disagree with the whole concept, if it fails CI, it just needs
> work.

Good point. I'll fix it.

[Sam Spilsbury (smspillaz)]

(Resubmitting again for some detailed feedback after fixing the CI quirk)

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:2405
http://s-jenkins:8080/job/unity-ci/19/

review: Approve (continuous-integration)

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:2405
http://s-jenkins:8080/job/unity-ci/20/

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

review: Abstain

[Sam Spilsbury (smspillaz)]

I am marking this Work in Progress for now.

Now that regionalDamage is merged in, there are going to be quite massive conflicts, all of which need to be cleaned up. Because regionalDamage has to use the same technique this branch is using, this branch will be re-purposed towards getting all of the paint optimization and stack placement code under test, since it is now going to be incredibly easy to break.

Unmerged revisions

2405. By Sam Spilsbury on 2012-06-26

Remove unused method and rename methods to make more sense

2404. By Sam Spilsbury on 2012-06-25

Merge lp:unity

2403. By Sam Spilsbury on 2012-06-19

Basic documentation, not really a substitute for better code ...

2402. By Sam Spilsbury on 2012-06-19

Nuke FBOBindingQueryInterface

2401. By Sam Spilsbury on 2012-06-19

unsigned int -> enum && move namespace compiz {} to namespace unity::compiz

2400. By Sam Spilsbury on 2012-06-19

Change namespace to unity::compiz

2399. By Sam Spilsbury on 2012-06-19

Merge lp:unity

2398. By Sam Spilsbury on 2012-06-17

Merge lp:unity

2397. By Sam Spilsbury on 2012-06-14

Test prohibited paint requestor retreival

2396. By Sam Spilsbury on 2012-06-14

Tests for RepaintPending value

=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-05-28 03:19:35 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-06-26 09:53:58 +0000
@@ -76,7 +76,6 @@
   mScreenSize = screenSize;
 }
 
-
 void unity::ScreenEffectFramebufferObject::unbind ()
 {
   if (!mBoundCnt)
@@ -212,7 +211,6 @@
   mBoundCnt++;
 }
 
-
 unity::ScreenEffectFramebufferObject::ScreenEffectFramebufferObject (GLXGetProcAddressProc p, const nux::Geometry &geom)
  : getProcAddressGLX (p)
  , mFboStatus (false)
 
=== modified file 'plugins/unityshell/src/compizminimizedwindowhandler.h'
--- plugins/unityshell/src/compizminimizedwindowhandler.h	2012-05-31 09:28:02 +0000
+++ plugins/unityshell/src/compizminimizedwindowhandler.h	2012-06-26 09:53:58 +0000
@@ -29,6 +29,7 @@
 #include <memory>
 
 // Will be merged back into compiz
+namespace unity {
 namespace compiz {
 
 class PrivateCompizMinimizedWindowHandler
@@ -357,5 +358,6 @@
       Window::get (w)->window->minimize();
   }
 }
+}
 
 #endif
 
=== modified file 'plugins/unityshell/src/comptransientfor.cpp'
--- plugins/unityshell/src/comptransientfor.cpp	2012-03-14 06:24:18 +0000
+++ plugins/unityshell/src/comptransientfor.cpp	2012-06-26 09:53:58 +0000
@@ -21,6 +21,8 @@
 
 #include "comptransientfor.h"
 
+namespace unity
+{
 namespace compiz
 {
 class PrivateCompTransientForReader
@@ -84,3 +86,4 @@
 
   return false;
 }
+}
 
=== modified file 'plugins/unityshell/src/comptransientfor.h'
--- plugins/unityshell/src/comptransientfor.h	2012-05-31 09:28:02 +0000
+++ plugins/unityshell/src/comptransientfor.h	2012-06-26 09:53:58 +0000
@@ -28,6 +28,8 @@
 #include "transientfor.h"
 
 // Will be merged back into compiz
+namespace unity
+{
 namespace compiz
 {
 class PrivateCompTransientForReader;
@@ -51,5 +53,6 @@
   PrivateCompTransientForReader *priv;
 };
 }
+}
 
 #endif
 
=== modified file 'plugins/unityshell/src/inputremover.cpp'
--- plugins/unityshell/src/inputremover.cpp	2012-03-24 02:57:48 +0000
+++ plugins/unityshell/src/inputremover.cpp	2012-06-26 09:53:58 +0000
@@ -24,6 +24,8 @@
 #include <cstdio>
 #include <cstring>
 
+namespace unity {
+
 compiz::WindowInputRemoverInterface::~WindowInputRemoverInterface ()
 {
 }
@@ -348,3 +350,4 @@
 
   return true;
 }
+}
 
=== modified file 'plugins/unityshell/src/inputremover.h'
--- plugins/unityshell/src/inputremover.h	2012-04-23 12:25:44 +0000
+++ plugins/unityshell/src/inputremover.h	2012-06-26 09:53:58 +0000
@@ -28,6 +28,7 @@
 #include <X11/extensions/shape.h>
 
 // Will be merged back into compiz
+namespace unity {
 namespace compiz {
 
 class WindowInputRemoverInterface
@@ -127,5 +128,6 @@
 };
 
 }
+}
 
 #endif
 
=== modified file 'plugins/unityshell/src/minimizedwindowhandler.cpp'
--- plugins/unityshell/src/minimizedwindowhandler.cpp	2012-04-23 12:25:44 +0000
+++ plugins/unityshell/src/minimizedwindowhandler.cpp	2012-06-26 09:53:58 +0000
@@ -23,6 +23,8 @@
 #include "inputremover.h"
 #include <cstring>
 
+namespace unity
+{
 namespace compiz
 {
 class PrivateMinimizedWindowHandler
@@ -273,3 +275,4 @@
 {
   delete priv;
 }
+}
 
=== modified file 'plugins/unityshell/src/minimizedwindowhandler.h'
--- plugins/unityshell/src/minimizedwindowhandler.h	2012-04-18 09:19:44 +0000
+++ plugins/unityshell/src/minimizedwindowhandler.h	2012-06-26 09:53:58 +0000
@@ -30,6 +30,8 @@
 #include <boost/bind.hpp>
 
 // Will be merged back into compiz
+namespace unity
+{
 namespace compiz
 {
 class PrivateMinimizedWindowHandler;
@@ -58,5 +60,6 @@
   PrivateMinimizedWindowHandler *priv;
 };
 }
+}
 
 #endif
 
=== modified file 'plugins/unityshell/src/transientfor.cpp'
--- plugins/unityshell/src/transientfor.cpp	2012-03-14 06:24:18 +0000
+++ plugins/unityshell/src/transientfor.cpp	2012-06-26 09:53:58 +0000
@@ -21,6 +21,9 @@
 
 #include "transientfor.h"
 
+namespace unity
+{
+
 Atom compiz::X11TransientForReader::wmTransientFor = None;
 Atom compiz::X11TransientForReader::wmClientLeader = None;
 
@@ -216,3 +219,4 @@
 {
   delete priv;
 }
+}
 
=== modified file 'plugins/unityshell/src/transientfor.h'
--- plugins/unityshell/src/transientfor.h	2012-05-31 09:28:02 +0000
+++ plugins/unityshell/src/transientfor.h	2012-06-26 09:53:58 +0000
@@ -29,6 +29,8 @@
 #include <string>
 
 // Will be merged back into compiz
+namespace unity
+{
 namespace compiz
 {
 class PrivateX11TransientForReader;
@@ -57,5 +59,6 @@
   PrivateX11TransientForReader *priv;
 };
 }
+}
 
 #endif
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-06-25 21:37:57 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-06-26 09:53:58 +0000
@@ -110,6 +110,8 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
+  , paint_dispatch_ (this,
+                     boost::bind (&UnityScreen::GetProhibitedPaintMasks, this))
   , debugger_(this)
   , enable_shortcut_overlay_(true)
   , gesture_engine_(screen)
@@ -117,8 +119,6 @@
   , _in_paint(false)
   , super_keypressed_(false)
   , newFocusedWindow(nullptr)
-  , doShellRepaint(false)
-  , allowWindowPaint(false)
   , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
@@ -263,8 +263,8 @@
      if (GL::fbo)
      {
        nux::Geometry geometry (0, 0, screen->width (), screen->height ());
-       uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
-       uScreen->_fbo->onScreenSizeChanged (geometry);
+       uScreen->fbo_ = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+       uScreen->fbo_->onScreenSizeChanged (geometry);
      }
 #endif
 
@@ -740,16 +740,41 @@
   panel_texture_has_changed_ = true;
 }
 
-#ifdef USE_MODERN_COMPIZ_GL
-void UnityScreen::paintDisplay()
-#else
-void UnityScreen::paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask)
+compiz::ShellPaintRequestorInterface::PaintRequestorType
+UnityScreen::GetPaintRequestorType ()
+{
+  return compiz::ShellPaintRequestorInterface::PaintRequestorType::Screen;
+}
+
+bool UnityScreen::PaintBackingFBO (CompOutput *output)
+{
+#ifndef USE_MODERN_COMPIZ_GL
+  bool was_bound = fbo_->bound ();
+  if (was_bound)
+  {
+    fbo_->unbind ();
+    GLMatrix sTransform;
+    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
+    glPushMatrix ();
+    glLoadMatrixf (sTransform.getMatrix ());
+    fbo_->paint (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+    glPopMatrix ();
+  }
+
+  return was_bound;
 #endif
+  return false;
+}
+
+void UnityScreen::PaintDisplay ()
 {
   CompOutput *output = _last_output;
 
 #ifndef USE_MODERN_COMPIZ_GL
-  bool was_bound = _fbo->bound ();
+  bool was_bound = PaintBackingFBO (output);
+#else
+  bool was_bound = true;
+#endif
 
   if (nux::GetGraphicsDisplay()->GetGraphicsEngine()->UsingGLSLCodePath())
   {
@@ -785,28 +810,18 @@
     }
   }
 
-  _fbo->unbind ();
-
   /* Draw the bit of the relevant framebuffer for each output */
 
-  if (was_bound)
-  {
-    GLMatrix sTransform;
-    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
-    glPushMatrix ();
-    glLoadMatrixf (sTransform.getMatrix ());
-    _fbo->paint (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
-    glPopMatrix ();
-  }
+  GLuint fbo_texture_name = 0;
+#ifndef USE_MODERN_COMPIZ_GL
+  fbo_texture_name = fbo_->texture();
+#else
+  fbo_texture_name = gScreen->fbo ()->tex ()->name ();
+#endif
 
   nux::ObjectPtr<nux::IOpenGLBaseTexture> device_texture =
-      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(_fbo->texture(),
+      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(fbo_texture_name,
                                                                        screen->width (), screen->height(), 1, nux::BITFMT_R8G8B8A8);
-#else
-  nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
-    nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(gScreen->fbo ()->tex ()->name (),
-      output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
-#endif
 
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
 
@@ -829,7 +844,7 @@
 
   for (Window tray_xid : panel_controller_->GetTrayXids())
   {
-    if (tray_xid && !allowWindowPaint)
+    if (tray_xid && (no_paint_allowed_mask_ == ShellPaintRequestorInterface::PaintRequestorType::Window))
     {
       CompWindow *tray = screen->findWindow (tray_xid);
 
@@ -907,15 +922,53 @@
     }
   }
 
-  doShellRepaint = false;
   damaged = false;
 }
 
-bool UnityScreen::forcePaintOnTop ()
-{
-    return !allowWindowPaint ||
-      ((switcher_controller_->Visible() || launcher_controller_->IsOverlayOpen())
-       && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
+compiz::ShellPaintRequestorInterface::PaintRequestorType UnityScreen::GetProhibitedPaintMasks()
+{
+  bool unity_force_overlay = switcher_controller_->Visible() || launcher_controller_->IsOverlayOpen();
+  bool no_screen_grabs = !(screen->grabbed () && !screen->otherGrabExist (NULL));
+  bool fullscreen_windows = !fullscreen_windows_.empty ();
+
+  compiz::ShellPaintRequestorInterface::PaintRequestorType pmask = no_paint_allowed_mask_;
+
+  if (unity_force_overlay &&
+      fullscreen_windows &&
+      no_screen_grabs)
+    pmask = compiz::ShellPaintRequestorInterface::PaintRequestorType::Window;
+
+  return pmask;
+}
+
+bool UnityScreen::RequestShellRepaint (compiz::ShellPaintRequestorInterface *r)
+{
+  return paint_dispatch_.RequestShellRepaint (r);
+}
+
+bool UnityScreen::EnforcePaintByRequestor (compiz::ShellPaintRequestorInterface *r)
+{
+  return paint_dispatch_.EnforcePaintByRequestor (r);
+}
+
+void UnityScreen::AllowPaintByAnyRequestor ()
+{
+  paint_dispatch_.AllowPaintByAnyRequestor ();
+}
+
+compiz::ShellPaintRequestorInterface::PaintRequestorType UnityScreen::ProhibitedPaintRequestors()
+{
+  return paint_dispatch_.ProhibitedPaintRequestors ();
+}
+
+void UnityScreen::RequireShellRepaint ()
+{
+  paint_dispatch_.RequireShellRepaint ();
+}
+
+bool UnityScreen::RepaintPending ()
+{
+  return paint_dispatch_.RepaintPending ();
 }
 
 void UnityWindow::paintThumbnail (nux::Geometry const& bounding, float alpha)
@@ -1210,8 +1263,9 @@
 {
   bool ret;
 
-  doShellRepaint = true;
-  allowWindowPaint = true;
+  AllowPaintByAnyRequestor ();
+  RequireShellRepaint ();
+  no_paint_allowed_mask_ = compiz::ShellPaintRequestorInterface::PaintRequestorType::Nil;
   _last_output = output;
   paint_panel_ = false;
 
@@ -1226,16 +1280,13 @@
    *   attempts to bind it will only increment
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
-  _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+  fbo_->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 #endif
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
 
-#ifndef USE_MODERN_COMPIZ_GL
-  if (doShellRepaint)
-    paintDisplay(region, transform, mask);
-#endif
+  RequestShellRepaint (this);
 
   return ret;
 }
@@ -1247,7 +1298,7 @@
 {
   bool useFbo = false;
 
-  if (doShellRepaint)
+  if (RepaintPending ())
   {
     oldFbo = fbo->bind ();
     useFbo = fbo->checkStatus () && fbo->tex ();
@@ -1256,7 +1307,7 @@
 	::GLFramebufferObject::rebind (oldFbo);
 	return;
     }
-    paintDisplay();
+    RequestShellRepaint (this);
     ::GLFramebufferObject::rebind (oldFbo);
   }
 
@@ -1273,7 +1324,7 @@
                                            CompOutput* output,
                                            unsigned int mask)
 {
-  allowWindowPaint = false;
+  no_paint_allowed_mask_ = compiz::ShellPaintRequestorInterface::PaintRequestorType::Window;
   gScreen->glPaintTransformedOutput(attrib, transform, region, output, mask);
 
 }
@@ -2132,31 +2183,6 @@
   return "Unity";
 }
 
-bool isNuxWindow (CompWindow* value)
-{
-  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-  auto id = value->id();
-
-  // iterate loop by hand rather than use std::find as this is considerably faster
-  // we care about performance here becuase of the high frequency in which this function is
-  // called (nearly every frame)
-  unsigned int size = xwns.size();
-  for (unsigned int i = 0; i < size; ++i)
-  {
-    if (xwns[i] == id)
-      return true;
-  }
-  return false;
-}
-
-const CompWindowList& UnityScreen::getWindowPaintList()
-{
-  CompWindowList& pl = _withRemovedNuxWindows = cScreen->getWindowPaintList();
-  pl.remove_if(isNuxWindow);
-
-  return pl;
-}
-
 void UnityScreen::RaiseInputWindows()
 {
   std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
@@ -2169,13 +2195,11 @@
   }
 }
 
-/* detect occlusions
- *
- * core passes down the PAINT_WINDOW_OCCLUSION_DETECTION
- * mask when it is doing occlusion detection, so use that
- * order to fill our occlusion buffer which we'll flip
- * to nux later
- */
+/* we want to paint underneath other windows here,
+ * so we need to find if this window is actually
+ * stacked on top of one of the nux input windows
+ * and if so paint nux and stop us from painting
+ * other windows or on top of the whole screen */
 bool UnityWindow::glPaint(const GLWindowPaintAttrib& attrib,
                           const GLMatrix& matrix,
                           const CompRegion& region,
@@ -2195,7 +2219,7 @@
 
   std::vector<Window> const& tray_xids = uScreen->panel_controller_->GetTrayXids();
   if (std::find(tray_xids.begin(), tray_xids.end(), window->id()) != tray_xids.end() &&
-      !uScreen->allowWindowPaint)
+      (uScreen->ProhibitedPaintRequestors () == compiz::ShellPaintRequestorInterface::PaintRequestorType::Window))
   {
     if (!uScreen->painting_tray_)
     {
@@ -2204,26 +2228,7 @@
     }
   }
 
-  return gWindow->glPaint(wAttrib, matrix, region, mask);
-}
-
-/* handle window painting in an opengl context
- *
- * we want to paint underneath other windows here,
- * so we need to find if this window is actually
- * stacked on top of one of the nux input windows
- * and if so paint nux and stop us from painting
- * other windows or on top of the whole screen */
-bool UnityWindow::glDraw(const GLMatrix& matrix,
-#ifndef USE_MODERN_COMPIZ_GL
-                         GLFragment::Attrib& attrib,
-#else
-                         const GLWindowPaintAttrib& attrib,
-#endif
-                         const CompRegion& region,
-                         unsigned int mask)
-{
-  if (uScreen->doShellRepaint && !uScreen->paint_panel_ && window->type() == CompWindowTypeNormalMask)
+  if (uScreen->RepaintPending () && !uScreen->paint_panel_ && window->type() == CompWindowTypeNormalMask)
   {
     guint32 id = window->id();
     bool maximized = WindowManager::Default()->IsWindowMaximized(id);
@@ -2239,29 +2244,63 @@
     }
   }
 
-  if (uScreen->doShellRepaint && !uScreen->forcePaintOnTop ())
+  if (IsNuxWindow ())
   {
-    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-    unsigned int size = xwns.size();
-
-    for (CompWindow* w = window; w && uScreen->doShellRepaint; w = w->prev)
-    {
-      auto id = w->id();
-
-      for (unsigned int i = 0; i < size; ++i)
-      {
-        if (xwns[i] == id)
-        {
-#ifdef USE_MODERN_COMPIZ_GL
-          uScreen->paintDisplay();
+    /* Windows are painted in top-to-bottom order
+     * with occlusion detection on, so we can
+     * find out the top most nux window and paint
+     * there */
+    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+    {
+      GLWindowPaintAttrib noAlphaAttrib;
+
+      noAlphaAttrib.opacity = OPAQUE;
+      noAlphaAttrib.brightness = BRIGHT;
+      noAlphaAttrib.saturation = COLOR;
+
+      bool status = gWindow->glPaint (noAlphaAttrib,
+                                      matrix,
+                                      region,
+                                      PAINT_WINDOW_OCCLUSION_DETECTION_MASK);
+
+      if (status)
+        uScreen->EnforcePaintByRequestor (this);
+
+      /* We don't want core to take this window
+       * into account when doing occlusion detection
+       * however */
+      return false;
+    }
+    /* Don't care about "fake" paints */
+    else if (mask & PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
+    {
+      return false;
+    }
+    else
+    {
+      uScreen->RequestShellRepaint (this);
+
+      /* Don't paint nux windows on the real paint pass */
+      return false;
+    }
+  }
+
+  return gWindow->glPaint(wAttrib, matrix, region, mask);
+}
+
+/* handle window painting in an opengl context
+ */
+bool UnityWindow::glDraw(const GLMatrix& matrix,
+#ifndef USE_MODERN_COMPIZ_GL
+                         GLFragment::Attrib& attrib,
 #else
-          uScreen->paintDisplay(region, matrix, mask);
+                         const GLWindowPaintAttrib& attrib,
 #endif
-          break;
-        }
-      }
-    }
-  }
+                         const CompRegion& region,
+                         unsigned int mask)
+{
+  if (IsNuxWindow ())
+    return false;
 
   if (window->type() == CompWindowTypeDesktopMask)
     uScreen->setPanelShadowMatrix(matrix);
@@ -2280,7 +2319,6 @@
     uScreen->paintPanelShadow(matrix);
   }
 
-
   return ret;
 }
 
@@ -2755,8 +2793,8 @@
 #ifndef USE_MODERN_COMPIZ_GL
   if (GL::fbo)
   {
-    uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
-    uScreen->_fbo->onScreenSizeChanged (geometry);
+    uScreen->fbo_ = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+    uScreen->fbo_->onScreenSizeChanged (geometry);
   }
 #endif
 
@@ -2922,6 +2960,18 @@
   hints_.push_back(std::make_shared<shortcut::Hint>(windows, "", _(" Drag"), _("Resize window."), shortcut::COMPIZ_MOUSE_OPTION, "resize", "initiate_button"));
 }
 
+bool
+UnityWindow::IsNuxWindow ()
+{
+  return is_nux_window_;
+}
+
+compiz::ShellPaintRequestorInterface::PaintRequestorType
+UnityWindow::GetPaintRequestorType ()
+{
+  return compiz::ShellPaintRequestorInterface::PaintRequestorType::Window;
+}
+
 /* Window init */
 UnityWindow::UnityWindow(CompWindow* window)
   : BaseSwitchWindow (dynamic_cast<BaseSwitchScreen *> (UnityScreen::get (screen)), window)
@@ -2930,10 +2980,16 @@
   , gWindow(GLWindow::get(window))
   , mMinimizeHandler()
   , mShowdesktopHandler(nullptr)
+  , is_nux_window_ (false)
 {
   WindowInterface::setHandler(window);
   GLWindowInterface::setHandler(gWindow);
 
+  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
+  for (unsigned int i = 0; i < xwns.size(); i++)
+    if (xwns[i] == window->id ())
+        is_nux_window_ = true;
+
   if (UnityScreen::get (screen)->optionGetShowMinimizedWindows () &&
       window->mapNum ())
   {
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-06-23 01:54:48 +0000
+++ plugins/unityshell/src/unityshell.h	2012-06-26 09:53:58 +0000
@@ -52,6 +52,7 @@
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
 #include "UnityShowdesktopHandler.h"
+#include "ShellPaintSchedule.h"
 #ifndef USE_MODERN_COMPIZ_GL
 #include "ScreenEffectFramebufferObject.h"
 #endif
@@ -68,6 +69,9 @@
 
 /* base screen class */
 class UnityScreen :
+  public compiz::ShellPaintDispatchInterface,
+  public compiz::ShellPaintRequestorInterface,
+  public compiz::ShellPaintInterface,
   public unity::debug::Introspectable,
   public sigc::trackable,
   public ScreenInterface,
@@ -92,11 +96,8 @@
   void nuxEpilogue();
 
   /* nux draw wrapper */
-#ifdef USE_MODERN_COMPIZ_GL
-  void paintDisplay();
-#else
-  void paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask);
-#endif
+  bool PaintBackingFBO (CompOutput *output);
+  void PaintDisplay ();
   void paintPanelShadow(const GLMatrix& matrix);
   void setPanelShadowMatrix(const GLMatrix& matrix);
 
@@ -133,9 +134,6 @@
                                 CompOutput*,
                                 unsigned int);
 
-  /* Pop our InputOutput windows from the paint list */
-  const CompWindowList& getWindowPaintList();
-
   /* handle X11 events */
   void handleEvent(XEvent*);
 
@@ -189,8 +187,6 @@
   void NeedsRelayout();
   void ScheduleRelayout(guint timeout);
 
-  bool forcePaintOnTop ();
-
 protected:
   std::string GetName() const;
   void AddProperties(GVariantBuilder* builder);
@@ -237,6 +233,18 @@
 
   void OnPanelStyleChanged();
 
+  compiz::ShellPaintRequestorInterface::PaintRequestorType GetPaintRequestorType ();
+  compiz::ShellPaintRequestorInterface::PaintRequestorType GetProhibitedPaintMasks ();
+
+  bool RequestShellRepaint (compiz::ShellPaintRequestorInterface *);
+  bool EnforcePaintByRequestor (compiz::ShellPaintRequestorInterface *);
+  void AllowPaintByAnyRequestor ();
+  ShellPaintRequestorInterface::PaintRequestorType ProhibitedPaintRequestors ();
+  void RequireShellRepaint ();
+  bool RepaintPending ();
+
+  compiz::ShellPaintDispatch paint_dispatch_;
+
   Settings dash_settings_;
   dash::Style    dash_style_;
   panel::Style   panel_style_;
@@ -276,12 +284,9 @@
   GLTexture::List _shadow_texture;
 
   /* handle paint order */
-  bool    doShellRepaint;
-  bool    allowWindowPaint;
   bool    damaged;
   bool    _key_nav_mode_requested;
   CompOutput* _last_output;
-  CompWindowList _withRemovedNuxWindows;
 
   nux::Property<nux::Geometry> primary_monitor_;
 
@@ -290,7 +295,7 @@
 #ifdef USE_MODERN_COMPIZ_GL
   ::GLFramebufferObject *oldFbo;
 #else
-  ScreenEffectFramebufferObject::Ptr _fbo;
+  ScreenEffectFramebufferObject::Ptr fbo_;
   GLuint                             _active_fbo;
 #endif
 
@@ -317,15 +322,27 @@
 
   UBusManager ubus_manager_;
   glib::SourceManager sources_;
+  compiz::ShellPaintRequestorInterface::PaintRequestorType no_paint_allowed_mask_;
 
   friend class UnityWindow;
 };
 
+class NuxBridgeWindowInterface
+{
+public:
+
+  virtual ~NuxBridgeWindowInterface () {};
+
+  virtual bool IsNuxWindow () = 0;
+};
+
 class UnityWindow :
   public WindowInterface,
   public GLWindowInterface,
   public ShowdesktopHandlerWindowInterface,
   public compiz::WindowInputRemoverLockAcquireInterface,
+  public NuxBridgeWindowInterface,
+  public compiz::ShellPaintRequestorInterface,
   public BaseSwitchWindow,
   public PluginClassHandler <UnityWindow, CompWindow>
 {
@@ -423,7 +440,12 @@
 
   compiz::WindowInputRemoverLock::Ptr GetInputRemover ();
 
+  bool IsNuxWindow ();
+  compiz::ShellPaintRequestorInterface::PaintRequestorType GetPaintRequestorType ();
+
   compiz::WindowInputRemoverLock::Weak input_remover_;
+
+  bool is_nux_window_;
   glib::Source::UniquePtr focus_desktop_timeout_;
 };
 
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-06-20 12:35:22 +0000
+++ tests/CMakeLists.txt	2012-06-26 09:53:58 +0000
@@ -150,6 +150,7 @@
                  test_unityshell_private.cpp
                  test_showdesktop_handler.cpp
                  test_hud_private.cpp
+                 test_shell_paint_schedule.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/AbstractLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Animator.cpp
                  ${UNITY_SRC}/DebugDBusInterface.cpp
@@ -162,6 +163,7 @@
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStorePrivate.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutModel.cpp
                  ${CMAKE_SOURCE_DIR}/shortcuts/ShortcutHintPrivate.cpp
+		 ${CMAKE_SOURCE_DIR}/unity-shared/ShellPaintSchedule.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Introspectable.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/TextureCache.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Timer.cpp
 
=== modified file 'tests/test-input-remover/test-input-remover.cpp'
--- tests/test-input-remover/test-input-remover.cpp	2011-09-13 12:52:31 +0000
+++ tests/test-input-remover/test-input-remover.cpp	2012-06-26 09:53:58 +0000
@@ -27,6 +27,8 @@
 #include <unistd.h> 
 #include <sstream>
 
+using namespace unity;
+
 void usage ()
 {
   std::cout << "test-input-remover [WINDOW] [TIME]" << std::endl;
 
=== modified file 'tests/test-minimize-window-handler/test-minimize-handler.cpp'
--- tests/test-minimize-window-handler/test-minimize-handler.cpp	2012-04-18 09:19:44 +0000
+++ tests/test-minimize-window-handler/test-minimize-handler.cpp	2012-06-26 09:53:58 +0000
@@ -34,6 +34,8 @@
 
 #include <x11-window-read-transients.h>
 
+using namespace unity;
+
 class X11WindowFakeMinimizable :
   public X11WindowReadTransients,
   public compiz::WindowInputRemoverLockAcquireInterface
 
=== added file 'tests/test_shell_paint_schedule.cpp'
--- tests/test_shell_paint_schedule.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_shell_paint_schedule.cpp	2012-06-26 09:53:58 +0000
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ *
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using ::testing::StrictMock;
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Return;
+
+#include "ShellPaintSchedule.h"
+
+using namespace unity::compiz;
+
+class MockShellPaintRequestor :
+  public ShellPaintRequestorInterface
+{
+public:
+
+  MOCK_METHOD0 (GetPaintRequestorType, PaintRequestorType ());
+
+  MockShellPaintRequestor ()
+  {
+    ON_CALL (*this, GetPaintRequestorType ()).WillByDefault (Return (ShellPaintRequestorInterface::PaintRequestorType::Nil));
+  }
+
+};
+
+class MockShellPaint :
+  public ShellPaintInterface
+{
+public:
+
+  MOCK_METHOD0 (PaintDisplay, void ());
+};
+
+class MockShellPaintDispatch
+{
+public:
+
+  MOCK_METHOD1 (Paint, bool (ShellPaintRequestorInterface *));
+  MOCK_METHOD1 (EnforceRequestor, void (ShellPaintRequestorInterface *));
+  MOCK_METHOD0 (ClearRequestorEnforcement, void ());
+  MOCK_METHOD0 (ProhibitedPaintRequestors, ShellPaintRequestorInterface::PaintRequestorType ());
+  MOCK_METHOD0 (RequireShellRepaint, void ());
+  MOCK_METHOD0 (RepaintPending, bool ());
+};
+
+class TestShellPaintSchedule :
+  public ::testing::Test
+{
+};
+
+TEST(TestShellPaintSchedule, NoPaintWhereNotRequired)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequestShellRepaint (&r);
+}
+
+TEST(TestShellPaintSchedule, PaintWhereRequired)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r);
+}
+
+TEST(TestShellPaintSchedule, NoPaintTwice)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r);
+  dispatch.RequestShellRepaint (&r);
+}
+
+TEST(TestShellPaintSchedule, NoWindowPaintButScreenPaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Window; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+
+  dispatch.RequestShellRepaint (&r);
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Screen));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r);
+}
+
+TEST(TestShellPaintSchedule, NoScreenPaintButWindowPaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Screen; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Screen));
+
+  dispatch.RequestShellRepaint (&r);
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r);
+}
+
+TEST(TestShellPaintSchedule, TopRequestorOnlyPaints)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.AllowPaintByAnyRequestor ();
+  dispatch.EnforcePaintByRequestor (&r_w2);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+
+  dispatch.RequestShellRepaint (&r_w1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r_w2);
+}
+
+TEST(TestShellPaintSchedule, SuperveningRequestorOfOtherTypePaints)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2, r_s1;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.AllowPaintByAnyRequestor ();
+  dispatch.EnforcePaintByRequestor (&r_w2);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+
+  dispatch.RequestShellRepaint (&r_w1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (r_s1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Screen));
+
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r_s1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+
+  dispatch.RequestShellRepaint (&r_w2);
+}
+
+TEST(TestShellPaintSchedule, DoubleEnforcementHasNoEffect)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r_w1, r_w2;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  dispatch.RequireShellRepaint ();
+
+  dispatch.AllowPaintByAnyRequestor ();
+  dispatch.EnforcePaintByRequestor (&r_w2);
+  dispatch.EnforcePaintByRequestor (&r_w1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (r_w1, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+
+  dispatch.RequestShellRepaint (&r_w1);
+
+  EXPECT_CALL (r_w2, GetPaintRequestorType ()).WillRepeatedly (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r_w2);
+}
+
+TEST(TestShellPaintSchedule, GetPendingRepaint)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([]() -> ShellPaintRequestorInterface::PaintRequestorType { return ShellPaintRequestorInterface::PaintRequestorType::Nil; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  EXPECT_FALSE (dispatch.RepaintPending ());
+
+  dispatch.RequireShellRepaint ();
+
+  EXPECT_TRUE (dispatch.RepaintPending ());
+
+  EXPECT_CALL (r, GetPaintRequestorType ()).WillOnce (Return (ShellPaintRequestorInterface::PaintRequestorType::Window));
+  EXPECT_CALL (p, PaintDisplay ());
+
+  dispatch.RequestShellRepaint (&r);
+
+  EXPECT_FALSE (dispatch.RepaintPending ());
+}
+
+TEST(TestShellPaintSchedule, GetProhibitedPaintMasks)
+{
+  StrictMock <MockShellPaint> p;
+  MockShellPaintRequestor r;
+  ShellPaintRequestorInterface::PaintRequestorType prohibited_paint_mask = ShellPaintRequestorInterface::PaintRequestorType::Nil;
+  ShellPaintDispatch::GetProhibitedPaintMasksFunc f ([&]() -> ShellPaintRequestorInterface::PaintRequestorType { return prohibited_paint_mask; } );
+
+  ShellPaintDispatch dispatch (&p, f);
+
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+  prohibited_paint_mask = ShellPaintRequestorInterface::PaintRequestorType::Window;
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+  prohibited_paint_mask = ShellPaintRequestorInterface::PaintRequestorType::Screen;
+  EXPECT_EQ (prohibited_paint_mask, dispatch.ProhibitedPaintRequestors ());
+}
 
=== modified file 'tests/test_showdesktop_handler.cpp'
--- tests/test_showdesktop_handler.cpp	2012-04-18 09:30:53 +0000
+++ tests/test_showdesktop_handler.cpp	2012-06-26 09:53:58 +0000
@@ -4,12 +4,14 @@
 #include <gmock/gmock.h>
 #include <UnityShowdesktopHandler.h>
 
-using namespace unity;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::Invoke;
 using ::testing::InSequence;
 
+namespace unity
+{
+
 compiz::WindowInputRemoverInterface::~WindowInputRemoverInterface () {}
 
 class MockWindowInputRemover :
@@ -96,11 +98,16 @@
     MOCK_METHOD0 (DoDeleteHandler, void ());
 };
 
+}
+
+using namespace unity;
+using namespace unity::compiz;
+
 TEST_F(UnityShowdesktopHandlerTest, TestNoORWindowsSD)
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ()).WillOnce (Return (true));
   EXPECT_FALSE (ShowdesktopHandler::ShouldHide (&mMockWindow));
@@ -110,7 +117,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ()).WillOnce (Return (false));
@@ -121,7 +128,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -133,7 +140,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -146,7 +153,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -160,7 +167,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -177,7 +184,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -193,7 +200,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -211,7 +218,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsOverrideRedirect ());
   EXPECT_CALL (mMockWindow, IsManaged ());
@@ -226,7 +233,7 @@
 }
 
 class MockWindowInputRemoverTestFadeOut :
-  public compiz::WindowInputRemoverInterface
+  public WindowInputRemoverInterface
 {
   public:
 
@@ -252,7 +259,7 @@
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOut>));
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -264,7 +271,7 @@
 }
 
 class MockWindowInputRemoverTestFadeOutAlready :
-  public compiz::WindowInputRemoverInterface
+  public WindowInputRemoverInterface
 {
   public:
 
@@ -284,7 +291,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ()).WillOnce (Return (true));
 
@@ -298,7 +305,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOut>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -314,7 +321,7 @@
 {
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   mMockHandler.FadeIn ();
 
@@ -322,7 +329,7 @@
 }
 
 class MockWindowInputRemoverTestFadeOutFadeIn :
-  public compiz::WindowInputRemoverInterface
+  public WindowInputRemoverInterface
 {
   public:
 
@@ -347,7 +354,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOutFadeIn>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -368,7 +375,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOutFadeIn>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -409,7 +416,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOutFadeIn>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -465,7 +472,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOutFadeIn>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
@@ -491,7 +498,7 @@
 }
 
 class MockWindowInputRemoverTestFadeOutFadeInWithShapeEvent :
-  public compiz::WindowInputRemoverInterface
+  public WindowInputRemoverInterface
 {
   public:
 
@@ -520,7 +527,7 @@
   MockUnityShowdesktopHandlerWindow mMockWindow;
 
   EXPECT_CALL (mMockWindow, GetInputRemover ()).WillOnce (Invoke (UnityShowdesktopHandlerTest::getLock <MockWindowInputRemoverTestFadeOutFadeInWithShapeEvent>));
-  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <compiz::WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
+  ShowdesktopHandler mMockHandler (static_cast <ShowdesktopHandlerWindowInterface *> (&mMockWindow), static_cast <WindowInputRemoverLockAcquireInterface *> (&mMockWindow));
 
   EXPECT_CALL (mMockWindow, IsHidden ());
   EXPECT_CALL (mMockWindow, DoHide ());
 
=== modified file 'tests/x11-window-read-transients.cpp'
--- tests/x11-window-read-transients.cpp	2011-08-24 16:46:09 +0000
+++ tests/x11-window-read-transients.cpp	2012-06-26 09:53:58 +0000
@@ -25,6 +25,8 @@
 #define _GNU_SOURCE
 #endif
 
+using namespace unity;
+
 X11WindowReadTransients::X11WindowReadTransients (Display *d, Window w) :
     X11Window::X11Window (d, w)
 {
 
=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2012-05-22 10:15:47 +0000
+++ unity-shared/CMakeLists.txt	2012-06-26 09:53:58 +0000
@@ -47,6 +47,7 @@
      PanelStyle.cpp
      SearchBar.cpp
      SearchBarSpinner.cpp
+     ShellPaintSchedule.cpp
      StaticCairoText.cpp
      TextureCache.cpp
      Timer.cpp
 
=== added file 'unity-shared/ShellPaintSchedule.cpp'
--- unity-shared/ShellPaintSchedule.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/ShellPaintSchedule.cpp	2012-06-26 09:53:58 +0000
@@ -0,0 +1,93 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ShellPaintSchedule.h"
+
+namespace unity
+{
+namespace compiz
+{
+
+ShellPaintDispatch::ShellPaintDispatch (ShellPaintInterface *paint_interface,
+                                        const GetProhibitedPaintMasksFunc &prohibited_func) :
+  shell_repaint_required_ (false),
+  top_requestor_ (nullptr),
+  prohibited_paint_masks_func_ (prohibited_func),
+  paint_interface_ (paint_interface)
+{
+}
+
+bool
+ShellPaintDispatch::RequestShellRepaint (ShellPaintRequestorInterface *requestor)
+{
+  if (!shell_repaint_required_)
+    return false;
+
+  if (prohibited_paint_masks_func_ () == requestor->GetPaintRequestorType ())
+    return false;
+
+  if (top_requestor_)
+    if ((top_requestor_->GetPaintRequestorType () ==
+        requestor->GetPaintRequestorType ()) && top_requestor_ != requestor)
+      return false;
+
+  paint_interface_->PaintDisplay ();
+
+  shell_repaint_required_ = false;
+
+  return true;
+}
+
+bool
+ShellPaintDispatch::EnforcePaintByRequestor (ShellPaintRequestorInterface *requestor)
+{
+  if (top_requestor_)
+    return false;
+
+  top_requestor_ = requestor;
+
+  return true;
+}
+
+void
+ShellPaintDispatch::AllowPaintByAnyRequestor ()
+{
+  top_requestor_ = nullptr;
+}
+
+ShellPaintRequestorInterface::PaintRequestorType
+ShellPaintDispatch::ProhibitedPaintRequestors ()
+{
+  return prohibited_paint_masks_func_ ();
+}
+
+void
+ShellPaintDispatch::RequireShellRepaint ()
+{
+  shell_repaint_required_ = true;
+}
+
+bool
+ShellPaintDispatch::RepaintPending ()
+{
+  return shell_repaint_required_;
+}
+
+}
+}
 
=== added file 'unity-shared/ShellPaintSchedule.h'
--- unity-shared/ShellPaintSchedule.h	1970-01-01 00:00:00 +0000
+++ unity-shared/ShellPaintSchedule.h	2012-06-26 09:53:58 +0000
@@ -0,0 +1,125 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef UNITY_PAINT_SCHEDULE_H
+#define UNITY_PAINT_SCHEDULE_H
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+namespace unity
+{
+namespace compiz
+{
+
+/*
+ * Implementors of ShellPaintRequestorInterface are able
+ * to request a repaint of the unity shell by calling
+ * Paint () in ShellPaintDispatchInterface. Requestors
+ * must identify themselves to an implementor of
+ * ShellPaintDispatchInterface such that ShellPaintDispatch
+ * interface can decide whether to allow a redraw
+ */
+class ShellPaintRequestorInterface
+{
+public:
+
+  enum class PaintRequestorType
+  {
+    Nil = 0,
+    Window = (1 << 0),
+    Screen = (1 << 1)
+  };
+
+  virtual ~ShellPaintRequestorInterface () {}
+
+  virtual PaintRequestorType GetPaintRequestorType () = 0;
+};
+
+/*
+ * Implementors of ShellPaintInterface are capable
+ * of repainting the shell */
+class ShellPaintInterface
+{
+public:
+
+  virtual ~ShellPaintInterface () {};
+
+  virtual void PaintDisplay () = 0;
+};
+
+/*
+ * Implementors of ShellPaintDispatchInterface
+ * manage when the shell is allowed to be repainted
+ * by examining what is requesting the repaint of
+ * the shell and determining whether or not a
+ * repaint is required
+ */
+class ShellPaintDispatchInterface
+{
+public:
+
+  virtual ~ShellPaintDispatchInterface () {}
+
+  virtual bool RequestShellRepaint (ShellPaintRequestorInterface *) = 0;
+  virtual bool EnforcePaintByRequestor (ShellPaintRequestorInterface *) = 0;
+  virtual void AllowPaintByAnyRequestor () = 0;
+  virtual ShellPaintRequestorInterface::PaintRequestorType ProhibitedPaintRequestors () = 0;
+  virtual void RequireShellRepaint () = 0;
+  virtual bool RepaintPending () = 0;
+
+};
+
+/*
+ * ShellPaintDispatch is the canonical implementor
+ * of ShellPaintDispatchInterface and manages when
+ * the shell is allowed to be repainted depending
+ * on what ShellPaintRequestorInterface is requesting
+ * the repaint
+ */
+class ShellPaintDispatch :
+  public ShellPaintDispatchInterface
+{
+public:
+
+  typedef boost::function <ShellPaintRequestorInterface::PaintRequestorType ()> GetProhibitedPaintMasksFunc;
+
+  ShellPaintDispatch (ShellPaintInterface * paint_interface,
+                      const GetProhibitedPaintMasksFunc &func);
+
+  bool RequestShellRepaint (ShellPaintRequestorInterface *);
+  bool EnforcePaintByRequestor (ShellPaintRequestorInterface *);
+  void AllowPaintByAnyRequestor ();
+  ShellPaintRequestorInterface::PaintRequestorType ProhibitedPaintRequestors();
+  void RequireShellRepaint ();
+  bool RepaintPending ();
+
+
+protected:
+
+  bool shell_repaint_required_;
+  ShellPaintRequestorInterface *top_requestor_;
+  GetProhibitedPaintMasksFunc prohibited_paint_masks_func_;
+  ShellPaintInterface *paint_interface_;
+};
+
+}
+}
+
+#endif