Merge lp:~vanvugt/unity/regionalDamage into lp:unity

[Daniel van Vugt]

Stop Unity from redrawing the shell on every frame (ie. when it doesn't need
to). It had a severe impact on graphics performance. (LP: #988079)

This especially improves OpenGL application performance and multi-monitor
desktop performance. Because unity was previously slowing down compiz
rendering by 20-40% for each monitor added to the system. This slowdown no
longer occurs as only damaged areas of the unity shell are repainted. Now
unity will not have any impact on compiz rendering performance for most
video frames.

Coincidentally, this fixes a number of other bugs (linked).

For me, this branch eliminates the 25-30% slowdown (compared to regular compiz) when unity is running with a single monitor. With 2 monitors, this branch eliminates the 75%(!) slowdown experienced when unity is running. Extrapolate and hypothesize as you like.

Even simple things like scrolling in a web browser are nicer with this branch. Scrolling is smoother and faster when you don't have to render the shell on every frame.

In multi-monitor tests, unity was slowing down my system to the point of only rendering 30 FPS with two monitors. That's half what it should be. With this branch, I get 60 FPS like I should.

WARNING: This fix can only work if no window is redrawing _under_ a panel or launcher. If you have something drawing under the panel, launcher, tooltip or quicklist, then the shell will need to redraw and you won't get any performance benefit. Fixing that is a much bigger job and should be considered separate.

[Sam Spilsbury (smspillaz)]

227 + /*
228 + * The shell is hidden if there exists any window that fully covers
229 + * the output and is in front of all Nux windows on that output.
230 + * We could also check CompositeWindow::opacity() but that would be slower
231 + * and almost always pointless.
232 + */
233 + if (w->isMapped() &&
234 + w->isViewable() &&
235 + !w->inShowDesktopMode() && // Why must this != isViewable?
236 + w->geometry().contains(output))

What might be faster here is using the occlusion detection passes from core. That will take into account whether or not the window is truly occluded. Usually you can get this by checking gw->clip () in GLWindow.

This code won't work for windows that are semitransparent or have an alpha channel, which will work a little weird.

[Andrea Azzarone (azzar1)]

Does it fix bug 977984 too?

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

I guess you can even remove this now

const std::string REDRAW_IDLE = "redraw-idle";

in: if (launcher_controller_.get()) no need for .get().

Overall looks good...

PS: pay attention to style, i.e.:
 bool UnityScreen::shellIsHidden(const CompOutput &output) -> bool UnityScreen::ShellIsHidden(CompOutput const& output)
 const std::vector<Window> &nuxwins(nux::XInputWindow::NativeHandleList()); -> std::vector<Window> const& nuxwins(nux::XInputWindow::NativeHandleList());

[Daniel van Vugt (vanvugt)]

Marco, I think your style is wrong :)
In C and C++, & and * are part of the variable, not part of the type:
    A b, *c, d, &e(b);
That is why they usually go next to the variable and not the type.

Also, the Google C++ style guide that Unity is meant to use agrees:
    http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Reference_Arguments
but then it allows both styles :)
    http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Pointer_and_Reference_Expressions

[Daniel van Vugt (vanvugt)]

Andrea, no I don't think this will fix bug 977984.

[Daniel van Vugt (vanvugt)]

Sam, gw->priv->clip only seems to get updated after glPaintOutputs which looks too late. How does one use clip() normally?

shellIsHidden is designed to be fast. And it is AFAIK. Yes, I did already add a comment about transparent windows. But we're only talking about fullscreen windows here. And I don't think the case of transparent or alpha fullscreen windows is one that we should need to waste time handling. If you make a fullscreen window transparent then you won't see the shell behind it. Does that matter?

[Daniel van Vugt (vanvugt)]

Actually, it does matter. The whole point of this proposal is to avoid rendering the shell because it hogs so much GPU. So I think we should not be rendering the shell if it is stacked below a transparent fullscreen window.

[Daniel van Vugt (vanvugt)]

Just noticed a bug with NVIDIA:
Un-fullscreening a window does not damage the screen (!?) so the shell doesn't repaint until something changes or you use it. Not sure about the most elegant fix. It looks like a compiz bug, but I haven't yet proven it.

[Daniel van Vugt (vanvugt)]

review: Needs Fixing

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

> Marco, I think your style is wrong :)
> In C and C++, & and * are part of the variable, not part of the type:
> A b, *c, d, &e(b);
> That is why they usually go next to the variable and not the type.

I know, and that's how I used to do before, but the Unity style guide is different, see:
http://bazaar.launchpad.net/~unity-team/unity/trunk/view/head:/guides/cppguide.xml
(recently updated by Tim) http://bazaar.launchpad.net/~unity-team/unity/trunk/revision/2378

So here we use:
PointerType* ptr;
Object const& obj = ...;

[Sam Spilsbury (smspillaz)]

> Sam, gw->priv->clip only seems to get updated after glPaintOutputs which looks
> too late. How does one use clip() normally?

The clip region is updated after the occlusion pass. You are right, this happens within paintOutputRegion and not paintOutputs like I thought.

I feel like there are two options here:

1. Framebuffer object rebinds are not condition on whether or not the shell is repainting, but just as it is now with BackgroundEffectHelper::HasDirtyHelpers (). That leaves the problem of windows on top of the shell. At the moment, the damage collection code examines all damage events, but we don't care about stuff underneath the shell. As such, you could probably ignore any damage events coming in between PaintDisplay and glPaintOutput (damageRegionSetEnabled (false)). I don't think this will handle the case of fullscreen windows on top of the shell very well however. In compiz at least, we'd need a concept of layered damage, which is not trivial as it requires all damage to be tied to a particular object.

At this point, you can determine whether or not to paint the shell when you actually hit a nux window. This again, depends on being able to see nux windows in the paint stack (see lp:~smspillaz/unity/unity.less-paint-insanity). I guess at the moment, you could use the heuristic, and then Window -> CompWindow the nux window and check the clip region there to see if it is empty.

2. Second option is a bit trickier, but might also work. You'll need to effectively make unity do the occlusion pass. What you would do here is loop all the windows and do something like:

class UnityWindow :
....
{
....
private:

    CompRegion clip_;
};

void DetectOcclusionsOnUnityWindows (const GLMatrix &matrix,
                                     CompOutput *output)
{
GLWindowPaintAttrib a;
CompRegion tmpRegion (*output);

/* Top to bottom */
for (CompWindow *w : screen->reverseWindows ())
{
    UnityWindow *uw = UnityWindow::get (w);

    /* We only care about windows we actually clipped */
    clip = infiniteRegion;

    if (window->alpha ())
        continue;

    if (!window->isViewable ())
        continue;

    /* GLWindow::glPaint will return true if this window should be regarded
     * as occluding other windows. PAINT_WINDOW_OCCLUSION_DETECTION_MASK will
     * not actually paint the window, but will allow plugins to modify the state
     * of the window as if it was being painted, so we will know whether it should
     * occlude other windows */
    if (gw->glPaint (a, matrix, tmpRegion, PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
        tmpRegion -= w->region (); // Not inputRect () or outputRect (): Decorations are ARGB windows

    uw->clip_ = tmpRegion;
}
}

Now, you can loop the list of nux windows (probably safe to store that internally, a nux window is a nux window for life, just detect it on the UnityWindow ctor) and see if they all have empty clip regions. If so, don't paint the shell.

You can also use the region detection to determine what parts of the shell to "damage" as well.

iirc, this is something similar to what the blur plugin does. Have a look at that for other ideas. This will also fix problems to do with ...

[Daniel van Vugt (vanvugt)]

I am keeping shellIsHidden because it is fast and simple. It doesn't re-enter compiz and doesn't require any CompRegion logic. It just uses rectangles.

[Sam Spilsbury (smspillaz)]

> I am keeping shellIsHidden because it is fast and simple. It doesn't re-enter
> compiz and doesn't require any CompRegion logic. It just uses rectangles.

My gripe with shellIsHidden is that it is inaccurate and will run into lots of edge cases. It doesn't make visual sense when you have windows with alpha regions, transparency or transformations preventing the shell from painting if the bounding area occludes the shell. Its pretty much defeats the purpose of having alpha regions, shape regions and transformations in the first place. You can easily run into cases where the shell won't paint even when it should, and I think that's bad. Unless you have a way to handle those cases, or a very strong argument as to why we shouldn't handle those cases, I honestly think its a blocking factor here.

The OpenGL plugin already uses similar looking logic to do its occlusion detection, and there is very little (if any) performance penalty for it. There is hardly any CompRegion allocation at all, because the variables are stored locally. In fact, every time I've callgrinded compiz, paintOutputRegion has not appeared as a hotspot anywhere. The re-entrancy into compiz is also very inexpensive because most plugins will have glPaint disabled if they are not running any animations.

I would suggest at least trying to make it work.

Other bits of review:

121 +std::vector<nux::View*> Controller::Impl::GetPanelViews() const
122 +{
123 + std::vector<nux::View*> views;
124 + views.reserve(windows_.size());
125 + for (auto window: windows_)
126 + views.push_back(ViewForWindow(window));
127 + return views;
128 +}
129 +

I think it probably makes more sense to have the panel controller keep track of the views in its own vector so that you can just return a const ref to the vector. Since we're going to be calling this function every time we call compizDamageNux, the cost of doing the initial tracking for outweighs the cost of the query here.

270 + w->isViewable() &&
271 + !w->inShowDesktopMode() && // Why must this != isViewable?

You probably wanted

w->state () & CompWindowStateHiddenMask

260 + // Loop through windows from back to front
261 + for (CompWindow* w : screen->windows ())
262 + {

If you still want to use this, it would be easier to go front to back, I had to read the code like 8 times to figure out how it worked.

// front to back
for (CompWindow *w : screen->reverseWindows ())
{
 if (w->isMapped() &&
  w->isViewable() &&
  !w->inShowDesktopMode() && // Why must this != isViewable?
  w->geometry().contains(output))
    return true; // a window that covers the whole output discovered at top first
 else
   for (Window id : nuxwins)
     if (w->id () == id && output->intersects (w->geometry ())
       return false; // a nux windows discovered first
}

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

Sam, if you want people to pay attention, use fewer words. I'll get to this later.

[Sam Spilsbury (smspillaz)]

> Sam, if you want people to pay attention, use fewer words. I'll get to this
> later.

I apologize for my verbosity. Some things are complicated. This is.

[Daniel van Vugt (vanvugt)]

ALPHA AND TRANSPARENCY
I can only find one edge case so far. Using the obs plugin make a fullscreen window translucent. I would like to be able to detect this using CompositeWindow opacity() and alpha(), but there are four problems with that:
  1. opacity() returns OPAQUE even after updateOpacity and even when the window is translucent. Bug?
  2. updateOpacity() triggers window damage. Not a good idea. Bug?
  3. updateOpacity() requires a round trip.
  4. alpha() is not implemented. Does it have a use?
Actually, obs doesn't use composite opacity at all. It stores opacity privately and I don't want to create a dependency of unityshell on obs. I know you've said the occlusion code is designed for all this, but I don't yet understand it. And I'm not going to use it until I understand what it's meant to do.

PANEL CONTROLLER
I would prefer to not modify the panel code at all. Also, I think the current design does the best at information hiding. I think it's only creating a vector that is typically size 1 or 2 anyway. So performance should not be an issue.

HIDDEN WINDOW DETECTION
Fixed as smspillaz suggested.

SHELLISHIDDEN
Fixed (simplified) as smspillaz suggested.

[Sam Spilsbury (smspillaz)]

Looks pretty good now :)

427 + if (isNuxWindow(window))
428 + {
429 + if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
430 + {
431 + uScreen->nuxRegion += window->geometry();
432 + uScreen->nuxRegion -= uScreen->overShell;
433 + }
434 + return false;
435 + }
436 + else if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK &&
437 + !(mask & PAINT_WINDOW_TRANSLUCENT_MASK) &&
438 + window->state() & CompWindowStateFullscreenMask)
439 + // && !window->alpha() <-- doesn't work. False positives.
440 + {
441 + uScreen->overShell += window->geometry();
442 + uScreen->overShell -= uScreen->nuxRegion;
443 + }

I can't quite tell based on the context of the diff, but its probably safer to put this after the glPaint call, eg

bool retval = gWindow->glPaint (attrib, transform, region, mask);

And then something like:

bool nux_window = isNuxWindow (window);

if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
{
  if (nux_window)
  {
    uScreen->nuxRegion += window->geometry();
    uScreen->nuxRegion -= uScreen->overShell;
  }
  else
  {
    if (window->alpha () && attrib.opacity != opaque)
      mask |= PAINT_WINDOW_TRANSLUCENT_MASK;

    unsigned int noOcclusionMask = PAINT_WINDOW_TRANSLUCENT_MASK | PAINT_WINDOW_TRANSFORMED_MASK | PAINT_WINDOW_NO_CORE_INSTANCE_MASK;

    if (!(mask & noOcclusionMask == noOcclusionMask))
    {
      uScreen->overShell += window->geometry();
      uScreen->overShell -= uScreen->nuxRegion;
    }
  }
}

if (nux_window)
  return false;

return retval;

In that sample, I didn't check to see if the window was a fullscreen window before adding it to the occlusion region. Reason being that it is possible that a nonfullscreen window can be validly stacked above the shell (think override redirect windows, onboard, some other corner cases involving fullscreen windows and nonfullscreen windows). Note also the flags for NO_CORE_INSTANCE_MASK and TRANSFORMED_MASK.

I think the code here for determining whether or not something is over the shell using the occlusion detection is the wrong way around. The occlusion pass happens from bottom to top, so what seems to happen is that for windows stacked top to bottom as such (nux windows prefixed with N)

N1 > N2 > N3 > 4 > 5 > 6

You'll end up with:

overShell = (6 + 5 + 4)
nuxRegion = ((N3 - overShell) + (N2 - overShell) + (N1 - overShell))

Since when we hit the isNuxWindow case at N3, we add N3 to nuxRegion, and then subtract overShell from it (even though those windows aren't actually over the shell).

If you have no windows underneath the shell and a fullscreen window on top like this:

F1 > N2 > N3 > N4 > 5 > 6 > 7

You'll end up with:

nuxRegion = N4 + N3 + N2
overShell = (7 + 6 + 5 + F1) - nuxRegion

So in that case, you'll have a fullscreen window over the shell, and the shell will paint. If you don't have a fullscreen window over the shell, then the parts underneath it will obscure the shell.

The solution in this case is probably to only start to collect the shell region, and clear the "overShell" region when you hit the first nux window in PAINT_WINDOW_OCCLUSION_DETECTION_MASK. Then once you hit another window, you can s...

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:2463
http://s-jenkins:8080/job/unity-ci/21/

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

review: Abstain

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:2469
http://s-jenkins:8080/job/unity-ci/29/

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

Okay, looks good.

I would suggest getting some of the more complicated parts of this code under test, but I'm happy with it as is.

review: Approve

[Tim Penhey (thumper)]

> std::vector<nux::View*> const& panels(panel_controller_->GetPanelViews());

This is very bad. You are taking a reference to a temporary.
Remove the const& and the standard library move semantics will make
sure that this is efficient.

Also there isn't really a need to get the list outside the range based for loop.

You could just say:

for (nux::View* view : panel_controller_->GetPanelViews())

Similarly for the other for loops.

> std::vector<nux::Geometry> const& dirty = wt->GetDrawList();

Again here you are taking a reference to a temporary.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

Those temporaries exist for the lifetime of the block they're created in, so it is safe.

[Tim Penhey (thumper)]

You are half right.

Temporaries exist for the duration of the expression they were created in.

Except if they are bound to a reference, in which case they live for the duration of the life of the reference, except in certain situation covered in section 12.2.5 of the standard.

I learned something today.

review: Approve

[Daniel van Vugt (vanvugt)]

Yes, I was only half right. I learned something too.

[Daniel d'Andrada (dandrader)]

It seems that this patch has caused a regression.

Use case:
 1 - have number of windows open
 2 - hold alt key
 3 - press tab key [switcher comes up]
 4 - click on some unselected icon

Expected outcome:
 Selected icon is instantly redrawn

Actual outcome:
 It frequently take several seconds for the switcher to be redrawn after SwitcherView calls QueueDraw()

Branches:
  lp:~dandrader/unity/switcher_click_test
  This this patch and the issue appears.

  lp:~dandrader/unity/switcher_click_test_older_trunk
  Does not have this patch and things work nice and dandy.

Background info:
I'm working on new gestures to switch between windows and interact with the window switcher (the alt-tab guy). The branches above have a snippet of my WIP code that enables a user to select a window by directly tapping/clicking over its icon on the switcher.

So is my code snipped doing something dumb or have this patch indeed caused a regresssion?

review: Needs Information

[Daniel d'Andrada (dandrader)]

Things came back to normal again with revision 2475.

=== modified file 'launcher/AbstractLauncherIcon.h'
--- launcher/AbstractLauncherIcon.h	2012-06-06 15:40:19 +0000
+++ launcher/AbstractLauncherIcon.h	2012-06-27 07:28:39 +0000
@@ -218,6 +218,7 @@
 
   sigc::signal<void, AbstractLauncherIcon::Ptr> needs_redraw;
   sigc::signal<void, AbstractLauncherIcon::Ptr> remove;
+  sigc::signal<void, nux::ObjectPtr<nux::View>> tooltip_visible;
   sigc::signal<void> visibility_changed;
 
   sigc::connection needs_redraw_connection;
 
=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2012-06-20 18:51:16 +0000
+++ launcher/Launcher.cpp	2012-06-27 07:28:39 +0000
@@ -1520,6 +1520,11 @@
   }
 }
 
+nux::ObjectPtr<nux::View> Launcher::GetActiveTooltip() const
+{
+  return _active_tooltip;
+}
+
 void Launcher::SetActionState(LauncherActionState actionstate)
 {
   if (_launcher_action_state == actionstate)
@@ -1681,6 +1686,7 @@
   EnsureAnimation();
 
   icon->needs_redraw.connect(sigc::mem_fun(this, &Launcher::OnIconNeedsRedraw));
+  icon->tooltip_visible.connect(sigc::mem_fun(this, &Launcher::OnTooltipVisible));
 }
 
 void Launcher::OnIconRemoved(AbstractLauncherIcon::Ptr icon)
@@ -1757,6 +1763,11 @@
   EnsureAnimation();
 }
 
+void Launcher::OnTooltipVisible(nux::ObjectPtr<nux::View> view)
+{
+  _active_tooltip = view;
+}
+
 void Launcher::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
 
 
=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2012-06-15 02:03:31 +0000
+++ launcher/Launcher.h	2012-06-27 07:28:39 +0000
@@ -96,6 +96,8 @@
     return _parent;
   };
 
+  nux::ObjectPtr<nux::View> GetActiveTooltip() const;  // nullptr = no tooltip
+
   virtual void RecvMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags);
   virtual void RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
   virtual void RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
@@ -269,6 +271,7 @@
   void OnOrderChanged();
 
   void OnIconNeedsRedraw(AbstractLauncherIcon::Ptr icon);
+  void OnTooltipVisible(nux::ObjectPtr<nux::View> view);
 
   void OnOverlayHidden(GVariant* data);
   void OnOverlayShown(GVariant* data);
@@ -311,6 +314,7 @@
 
   LauncherModel::Ptr _model;
   nux::BaseWindow* _parent;
+  nux::ObjectPtr<nux::View> _active_tooltip;
   QuicklistView* _active_quicklist;
 
   nux::HLayout* m_Layout;
 
=== modified file 'launcher/LauncherIcon.cpp'
--- launcher/LauncherIcon.cpp	2012-06-19 01:00:36 +0000
+++ launcher/LauncherIcon.cpp	2012-06-27 07:28:39 +0000
@@ -513,6 +513,7 @@
     LoadTooltip();
   _tooltip->ShowTooltipWithTipAt(tip_x, tip_y);
   _tooltip->ShowWindow(!tooltip_text().empty());
+  tooltip_visible.emit(_tooltip);
 }
 
 void
@@ -534,6 +535,7 @@
 
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 bool LauncherIcon::OpenQuicklist(bool select_first_item, int monitor)
@@ -653,6 +655,7 @@
 {
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 bool
 
=== modified file 'panel/PanelController.cpp'
--- panel/PanelController.cpp	2012-06-15 02:03:31 +0000
+++ panel/PanelController.cpp	2012-06-27 07:28:39 +0000
@@ -49,6 +49,7 @@
   void QueueRedraw();
 
   std::vector<Window> GetTrayXids() const;
+  std::vector<nux::View*> GetPanelViews() const;
   std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
@@ -106,6 +107,15 @@
   return xids;
 }
 
+std::vector<nux::View*> Controller::Impl::GetPanelViews() const
+{
+  std::vector<nux::View*> views;
+  views.reserve(windows_.size());
+  for (auto window: windows_)
+    views.push_back(ViewForWindow(window));
+  return views;
+}
+
 std::vector<nux::Geometry> Controller::Impl::GetGeometries() const
 {
   std::vector<nux::Geometry> geometries;
@@ -325,6 +335,11 @@
   return pimpl->GetTrayXids();
 }
 
+std::vector<nux::View*> Controller::GetPanelViews() const
+{
+  return pimpl->GetPanelViews();
+}
+
 std::vector<nux::Geometry> Controller::GetGeometries() const
 {
   return pimpl->GetGeometries();
 
=== modified file 'panel/PanelController.h'
--- panel/PanelController.h	2012-05-06 23:48:38 +0000
+++ panel/PanelController.h	2012-06-27 07:28:39 +0000
@@ -41,6 +41,7 @@
   void QueueRedraw();
 
   std::vector<Window> GetTrayXids() const;
+  std::vector<nux::View*> GetPanelViews() const;
   std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-06-26 18:34:03 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-06-27 07:28:39 +0000
@@ -100,7 +100,6 @@
 const unsigned int SCROLL_UP_BUTTON = 7;
 
 const std::string RELAYOUT_TIMEOUT = "relayout-timeout";
-const std::string REDRAW_IDLE = "redraw-idle";
 } // namespace local
 } // anon namespace
 
@@ -118,6 +117,7 @@
   , super_keypressed_(false)
   , newFocusedWindow(nullptr)
   , doShellRepaint(false)
+  , didShellRepaint(false)
   , allowWindowPaint(false)
   , damaged(false)
   , _key_nav_mode_requested(false)
@@ -909,6 +909,7 @@
   }
 
   doShellRepaint = false;
+  didShellRepaint = true;
   damaged = false;
 }
 
@@ -1211,7 +1212,15 @@
 {
   bool ret;
 
-  doShellRepaint = true;
+  /*
+   * Very important!
+   * Don't waste GPU and CPU rendering the shell on every frame if you don't
+   * need to. Doing so on every frame causes Nux to hog the GPU and slow down
+   * ALL rendering. (LP: #988079)
+   */
+  bool force = forcePaintOnTop() || PluginAdapter::Default()->IsExpoActive();
+  doShellRepaint = force || !(region.isEmpty() || wt->GetDrawList().empty());
+
   allowWindowPaint = true;
   _last_output = output;
   paint_panel_ = false;
@@ -1227,13 +1236,21 @@
    *   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 ()));
+  if (doShellRepaint)
+    _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 #endif
 
+  // CompRegion has no clear() method. So this is the fastest alternative.
+  aboveShell = CompRegion();
+  nuxRegion = CompRegion();
+
   /* 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 && !force && aboveShell.contains(*output))
+    doShellRepaint = false;
+
   if (doShellRepaint)
     paintDisplay(region, transform, mask);
 #endif
@@ -1286,16 +1303,32 @@
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
     wi->HandleAnimations (ms);
 
+  // Workaround Nux bug LP: #1014610:
   if (damaged)
   {
     damaged = false;
-    damageNuxRegions();
+    nuxDamageCompiz();
   }
 
+  compizDamageNux(cScreen->currentDamage());
+
+  didShellRepaint = false;
 }
 
 void UnityScreen::donePaint()
 {
+  /*
+   * It's only safe to clear the draw list if drawing actually occurred
+   * (i.e. the shell was not obscured behind a fullscreen window).
+   * If you clear the draw list and drawing has not occured then you'd be
+   * left with all your views thinking they're queued for drawing still and
+   * would refuse to redraw when you return from fullscreen.
+   * I think this is a Nux bug. ClearDrawList should ideally also mark all
+   * the queued views as draw_cmd_queued_=false.
+   */
+  if (didShellRepaint)
+    wt->ClearDrawList();
+
   std::list <ShowdesktopHandlerWindowInterface *> remove_windows;
 
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
@@ -1316,42 +1349,100 @@
   cScreen->donePaint ();
 }
 
+void UnityScreen::compizDamageNux(CompRegion const& damage)
+{
+  if (!launcher_controller_)
+    return;
+
+  CompRect::vector const& rects(damage.rects());
+  for (const CompRect &r : rects)
+  {
+    nux::Geometry geo(r.x(), r.y(), r.width(), r.height());
+    BackgroundEffectHelper::ProcessDamage(geo);
+  }
+
+  auto launchers = launcher_controller_->launchers();
+  for (auto launcher : launchers)
+  {
+    if (!launcher->Hidden())
+    {
+      nux::Geometry geo = launcher->GetAbsoluteGeometry();
+      CompRegion launcher_region(geo.x, geo.y, geo.width, geo.height);
+      if (damage.intersects(launcher_region))
+        launcher->QueueDraw();
+      nux::ObjectPtr<nux::View> tooltip = launcher->GetActiveTooltip();
+      if (!tooltip.IsNull())
+      {
+        nux::Geometry tip = tooltip->GetAbsoluteGeometry();
+        CompRegion tip_region(tip.x, tip.y, tip.width, tip.height);
+        if (damage.intersects(tip_region))
+          tooltip->QueueDraw();
+      }
+    }
+  }
+
+  std::vector<nux::View*> const& panels(panel_controller_->GetPanelViews());
+  for (nux::View* view : panels)
+  {
+    nux::Geometry geo = view->GetAbsoluteGeometry();
+    CompRegion panel_region(geo.x, geo.y, geo.width, geo.height);
+    if (damage.intersects(panel_region))
+      view->QueueDraw();
+  }
+
+  QuicklistManager* qm = QuicklistManager::Default();
+  if (qm)
+  {
+    QuicklistView* view = qm->Current();
+    if (view)
+    {
+      nux::Geometry geo = view->GetAbsoluteGeometry();
+      CompRegion quicklist_region(geo.x, geo.y, geo.width, geo.height);
+      if (damage.intersects(quicklist_region))
+        view->QueueDraw();
+    }
+  }
+}
+
 /* Grab changed nux regions and add damage rects for them */
-void UnityScreen::damageNuxRegions()
+void UnityScreen::nuxDamageCompiz()
 {
+  // Workaround Nux bug LP: #1014610 (unbounded DrawList growth)
+  // Also, ensure we don't dereference null *controller_ on startup.
+  if (damaged || !launcher_controller_ || !dash_controller_)
+    return;
+  damaged = true;
+
   CompRegion nux_damage;
 
-  if (damaged)
-    return;
-
-  std::vector<nux::Geometry> dirty = wt->GetDrawList();
-  damaged = true;
-
-  for (std::vector<nux::Geometry>::iterator it = dirty.begin(), end = dirty.end();
-       it != end; ++it)
-  {
-    nux::Geometry const& geo = *it;
-    nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
-  }
-
-  nux::Geometry geo = wt->GetWindowCompositor().GetTooltipMainWindowGeometry();
-  nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
-
-  geo = lastTooltipArea;
-  nux_damage += CompRegion(lastTooltipArea.x, lastTooltipArea.y,
-                         lastTooltipArea.width, lastTooltipArea.height);
-
-  /*
-   * Avoid Nux damaging Nux as recommended by smspillaz. Though I don't
-   * believe it would be harmful or significantly expensive right now.
-   */
+  std::vector<nux::Geometry> const& dirty = wt->GetDrawList();
+  for (auto geo : dirty)
+    nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
+
+  if (launcher_controller_->IsOverlayOpen())
+  {
+    nux::BaseWindow* dash_window = dash_controller_->window();
+    nux::Geometry const& geo = dash_window->GetAbsoluteGeometry();
+    nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
+  }
+
+  auto launchers = launcher_controller_->launchers();
+  for (auto launcher : launchers)
+  {
+    if (!launcher->Hidden())
+    {
+      nux::ObjectPtr<nux::View> tooltip = launcher->GetActiveTooltip();
+      if (!tooltip.IsNull())
+      {
+        nux::Geometry const& g = tooltip->GetAbsoluteGeometry();
+        nux_damage += CompRegion(g.x, g.y, g.width, g.height);
+      }
+    }
+  }
+
   cScreen->damageRegionSetEnabled(this, false);
   cScreen->damageRegion(nux_damage);
   cScreen->damageRegionSetEnabled(this, true);
-
-  wt->ClearDrawList();
-
-  lastTooltipArea = geo;
 }
 
 /* handle X Events */
@@ -1511,13 +1602,7 @@
 
 void UnityScreen::damageRegion(const CompRegion &region)
 {
-  const CompRect::vector &rects(region.rects());
-  for (const CompRect &r : rects)
-  {
-    nux::Geometry geo(r.x(), r.y(), r.width(), r.height());
-    BackgroundEffectHelper::ProcessDamage(geo);
-  }
-
+  compizDamageNux(region);
   cScreen->damageRegion(region);
 }
 
@@ -2173,14 +2258,6 @@
   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();
@@ -2205,6 +2282,35 @@
                           const CompRegion& region,
                           unsigned int mask)
 {
+  /*
+   * The occlusion pass tests windows from TOP to BOTTOM. That's opposite to
+   * the actual painting loop.
+   */
+  if (isNuxWindow(window))
+  {
+    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+    {
+      uScreen->nuxRegion += window->geometry();
+      uScreen->nuxRegion -= uScreen->aboveShell;
+    }
+    return false;  // Ensure nux windows are never painted by compiz
+  }
+  else if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+  {
+    static const unsigned int nonOcclusionBits =
+                              PAINT_WINDOW_TRANSLUCENT_MASK |
+                              PAINT_WINDOW_TRANSFORMED_MASK |
+                              PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
+    if (!(mask & nonOcclusionBits))
+        // And I've been advised to test other things, but they don't work:
+        // && (attrib.opacity == OPAQUE)) <-- Doesn't work; Only set in glDraw
+        // && !window->alpha() <-- Doesn't work; Opaque windows often have alpha
+    {
+      uScreen->aboveShell += window->geometry();
+      uScreen->aboveShell -= uScreen->nuxRegion;
+    }
+  }
+
   GLWindowPaintAttrib wAttrib = attrib;
 
   if (mMinimizeHandler)
@@ -2263,7 +2369,17 @@
     }
   }
 
-  if (uScreen->doShellRepaint && !uScreen->forcePaintOnTop ())
+  /*
+   * Paint the shell in *roughly* the compiz stacking order. This is only
+   * approximate because we're painting all the nux windows as soon as we find
+   * the bottom-most nux window (from bottom to top).
+   * But remember to avoid painting the shell if it's within the aboveShell
+   * region.
+   */
+  if (uScreen->doShellRepaint &&
+      !uScreen->forcePaintOnTop () &&
+      !uScreen->aboveShell.contains(window->geometry())
+     )
   {
     std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
     unsigned int size = xwns.size();
@@ -2578,25 +2694,7 @@
 
 void UnityScreen::onRedrawRequested()
 {
-  // disable blur updates so we dont waste perf. This can stall the blur during animations
-  // but ensures a smooth animation.
-  if (_in_paint)
-  {
-    if (!sources_.GetSource(local::REDRAW_IDLE))
-    {
-      auto redraw_idle(std::make_shared<glib::Idle>(glib::Source::Priority::DEFAULT));
-      sources_.Add(redraw_idle, local::REDRAW_IDLE);
-
-      redraw_idle->Run([&]() {
-        onRedrawRequested();
-        return false;
-      });
-    }
-  }
-  else
-  {
-    damageNuxRegions();
-  }
+  nuxDamageCompiz();
 }
 
 /* Handle option changes and plug that into nux windows */
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-06-26 17:34:31 +0000
+++ plugins/unityshell/src/unityshell.h	2012-06-27 07:28:39 +0000
@@ -133,9 +133,6 @@
                                 CompOutput*,
                                 unsigned int);
 
-  /* Pop our InputOutput windows from the paint list */
-  const CompWindowList& getWindowPaintList();
-
   /* handle X11 events */
   void handleEvent(XEvent*);
 
@@ -212,7 +209,10 @@
 
   bool initPluginActions();
   void initLauncher();
-  void damageNuxRegions();
+
+  void compizDamageNux(CompRegion const& region);
+  void nuxDamageCompiz();
+
   void onRedrawRequested();
   void Relayout();
 
@@ -260,7 +260,6 @@
   bool enable_shortcut_overlay_;
 
   GestureEngine                         gesture_engine_;
-  nux::Geometry                         lastTooltipArea;
   bool                                  needsRelayout;
   bool                                  _in_paint;
   bool                                  super_keypressed_;
@@ -277,11 +276,14 @@
 
   /* handle paint order */
   bool    doShellRepaint;
+  bool    didShellRepaint;
   bool    allowWindowPaint;
   bool    damaged;
   bool    _key_nav_mode_requested;
   CompOutput* _last_output;
-  CompWindowList _withRemovedNuxWindows;
+
+  CompRegion nuxRegion;
+  CompRegion aboveShell;
 
   nux::Property<nux::Geometry> primary_monitor_;