Merge lp:~thumper/unity/regional-damage-sru into lp:unity/5.0

[Tim Penhey]

Backport the fixes for regional damage, and the regressions that were introduced by it.
Fixes lots of bugs.

This branch backports the fixes for regional damage, and the regression that were introduced by it.

Fixes lots of bugs.

[Daniel van Vugt (vanvugt)]

Please note: This proposal has two external prerequisite fixes:
  bug 1012956 (already fixed in lp:compiz-core/0.9.7)
  bug 1014610 (already fixed in lp:nux/2.0)

It appears neither of these fixes have hit ubuntu yet.

[Daniel van Vugt (vanvugt)]

Looks OK but keeps crashing when I run it on nvidia-295.49. The crash does not happen with lp:unity/5.0 !?

(gdb) bt
#0 0x00007fb402b65e1e in ?? () from /usr/lib/nvidia-current-updates/libnvidia-glcore.so.295.49
#1 0x00007fb402c09da1 in ?? () from /usr/lib/nvidia-current-updates/libnvidia-glcore.so.295.49
#2 0x00007fb402e0ada1 in ?? () from /usr/lib/nvidia-current-updates/libnvidia-glcore.so.295.49
#3 0x00007fb402e081f3 in ?? () from /usr/lib/nvidia-current-updates/libnvidia-glcore.so.295.49
#4 0x00007fb3ff4df22a in nux::GraphicsEngine::QRP_GLSL_1Tex(int, int, int, int, nux::ObjectPtr<nux::IOpenGLBaseTexture>, nux::TexCoordXForm&, nux::color::Color const&) ()
   from /usr/lib/libnux-graphics-2.0.so.0
#5 0x00007fb3ff4c98e9 in nux::GraphicsEngine::QRP_1Tex(int, int, int, int, nux::ObjectPtr<nux::IOpenGLBaseTexture>, nux::TexCoordXForm&, nux::color::Color const&) ()
   from /usr/lib/libnux-graphics-2.0.so.0
#6 0x00007fb3ff822891 in nux::WindowCompositor::PresentBufferToScreen(nux::ObjectPtr<nux::IOpenGLBaseTexture>, int, int, bool, bool, float, bool) () from /usr/lib/libnux-2.0.so.0
#7 0x00007fb3ff825990 in nux::WindowCompositor::RenderTopViews(bool, std::list<nux::ObjectWeakPtr<nux::BaseWindow>, std::allocator<nux::ObjectWeakPtr<nux::BaseWindow> > >&, bool) ()
   from /usr/lib/libnux-2.0.so.0
#8 0x00007fb3ff825cca in nux::WindowCompositor::Draw(bool, bool) () from /usr/lib/libnux-2.0.so.0
#9 0x00007fb3ff82ccb1 in nux::WindowThread::RenderInterfaceFromForeignCmd(nux::Rect*) () from /usr/lib/libnux-2.0.so.0
#10 0x00007fb4003e8cc4 in unity::UnityScreen::paintDisplay (this=0x1f07220, region=..., transform=..., mask=65536) at /home/dan/bzr/unity/tim/plugins/unityshell/src/unityshell.cpp:829

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

And yes I did try compiling the latest lp:nux/2.0 as well. But when I use it, I get NO readable stacktrace of the crash.

[Daniel van Vugt (vanvugt)]

Uninstalled nvidia-295.49 and tested with nouveau. Now it works well.

Can anyone else confirm the nvidia crash?

review: Needs Information

[Daniel van Vugt (vanvugt)]

Verified; works on intel too. Why is only nvidia broken?!

[Brenton Hall (brent-hall-27)]

Compiled it. Running fine on ATI, using the open drivers.

[Brenton Hall (brent-hall-27)]

Been through the new manual tests for this branch. They all passed for ATI.

[Daniel van Vugt (vanvugt)]

Tested Unit 6.0 and Nux 3.0 again. They now crash in the same way on nvidia. So it's nothing to do with this branch.

I also upgraded nvidia 295.40 to 295.49 but no difference (other than the stack traces are now completely unreadable).

I suspect the nvidia problem could be related to bug 982485 or bug 980298. When run under valgrind, I get a rubbish stack, but it happens immediately after bug 988880, which might be relevant.

Anyway, this branch seems good but I can't test it on nvidia-current/nvidia-current-updates.

review: Approve

[Daniel van Vugt (vanvugt)]

Actually, bug 982626 seems to describe the exact crash I'm getting now. Let's make that a separate discussion to this.

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

I can confirm the crash on a Nvidia GeForce GT 650M, the first time I launched this unity branch it worked and it also seemed to fix the bug #915265, however it hanged and after reloading compiz (one or two times), I can't run it anymore.

Gdb complains issues related to the nvidia bloab, so... It's not helpful at all.

The same happens with trunk with this change enabled.

[Łukasz Zemczak (sil2100)]

I would probably like to have this fixed before releasing this as an SRU. I know we have the same bug in trunk and quantal, but Precise is a LTS, so we probably shouldn't release anything that has any known ill side-effects. So fixing bug #982626 becomes rather a priority here.

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

FYI this is the stacktrace of the crash that I'm getting http://paste.ubuntu.com/1121725/

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

A weird thing about this crash is that if I replace an unity sesssion, from unity it will always crash.
If I replace it after a tty switch, then there's no crash...

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

Using a bad workaround like this, seems to bypass the crash... http://paste.ubuntu.com/1122495/
Checking something better.

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

Ok, thanks to the Sam's tip, I got the proper fix for the crash that was affecting the nvidia cards (using the nvidia driver).

I've made a branch that fixes this, and that uses this one as prerequisite: lp:~3v1n0/unity/fix-nvidia-glDrawArrays-crash-5.0/+merge/117553

So, at this point I can approve this branch too.

review: Approve

[Łukasz Zemczak (sil2100)]

Since I already tested the branch, along with Alan and the Nice guys, I think it's safe to apply as the nvidia bug is getting handled as well.

review: Approve

[Unity Merger (unity-merger)]

No commit message specified.

=== modified file 'manual-tests/Dash.txt'
--- manual-tests/Dash.txt	2012-06-21 16:10:54 +0000
+++ manual-tests/Dash.txt	2012-07-26 05:12:23 +0000
@@ -203,6 +203,21 @@
 Outcome:
   The Dash should close and the music file should open up in Firefox.
 
+
+DnD stacking
+------------
+
+Setup:
+#. Open the Dash (Super).
+
+Action:
+#. Drag any icon from the dash and wave it over the dash and launcher area.
+
+Outcome:
+  The icon being dragged is drawn on top of the dash and launcher. Never
+  below it.
+
+
 Lens Tests
 ============
 

=== modified file 'manual-tests/Launcher.txt'
--- manual-tests/Launcher.txt	2012-07-13 15:19:42 +0000
+++ manual-tests/Launcher.txt	2012-07-26 05:12:23 +0000
@@ -40,6 +40,21 @@
   in the last used workspace.
 
 
+Test Alt+F1 KeyNavMode Rendering
+--------------------------------
+This test shows that the launcher is redrawing correctly during Alt+F1
+KeyNav mode.
+
+Action:
+#. Press Alt+F1 to enter keynav mode.
+#. Keep pressing the down arrow key until the highlighted launcher icon is the
+   bottom one (usually Trash).
+
+Outcome:
+  For every Down keypress, the next launcher icon down should be highlighted.
+  Verify each icon gets highlighted from top to bottom.
+
+
 Test Alt+F1 KeyNavMode Mouse Works
 -------------------------------
 This test shows that the mouse still works normally while keynav mode is active.

=== modified file 'manual-tests/Panel.txt'
--- manual-tests/Panel.txt	2012-04-05 22:21:55 +0000
+++ manual-tests/Panel.txt	2012-07-26 05:12:23 +0000
@@ -69,3 +69,20 @@
 Expected Result:
   The panel should stay translucent
 
+
+Panel (and Launcher) blinking/flickering
+-----------------------------------------
+Setup:
+#. Optionally install "emacs23"
+
+Actions:
+#. Open LibreOffice Impress.
+#. Click on "Click to add title" and "Click to add text" a few times.
+#. Optionally: Run emacs23
+#. Optionally: Open a large file in emacs23.
+#. Optionally: Scroll to the bottom of the file using Page Down.
+
+Outcome:
+  At no point during the actions should the panel (or launcher) blink or
+  flicker out of existence.
+

=== modified file 'manual-tests/WindowManagement.txt'
--- manual-tests/WindowManagement.txt	2012-03-23 15:14:42 +0000
+++ manual-tests/WindowManagement.txt	2012-07-26 05:12:23 +0000
@@ -49,3 +49,23 @@
 
 Outcome:
   The window should be in the maximized state.
+
+
+Fullscreen windows
+--------------------
+Tests rendering of fullscreen windows.
+
+Action:
+#. Set a window to full screen. e.g. F11 in a web browser.
+#. Verify you can scroll the window.
+#. Tap the Super key.
+#. Verify you can still scroll the window.
+
+Outcome:
+  The fullscreen window should never look corrupt and always be scrollable.
+
+Recovery (in case of failure):
+#. Tap the Super key again.
+#. Tap F11 to leave full screen.
+#. Press Super+S twice to force a full screen redraw.
+

=== modified file 'plugins/unityshell/src/AbstractLauncherIcon.h'
--- plugins/unityshell/src/AbstractLauncherIcon.h	2012-07-16 11:03:18 +0000
+++ plugins/unityshell/src/AbstractLauncherIcon.h	2012-07-26 05:12:23 +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 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	2012-07-17 16:20:53 +0000
+++ plugins/unityshell/src/Launcher.cpp	2012-07-26 05:12:23 +0000
@@ -1655,6 +1655,11 @@
   }
 }
 
+nux::ObjectPtr<nux::View> Launcher::GetActiveTooltip() const
+{
+  return _active_tooltip;
+}
+
 void
 Launcher::SetActionState(LauncherActionState actionstate)
 {
@@ -1815,6 +1820,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)
@@ -1891,6 +1897,11 @@
   EnsureAnimation();
 }
 
+void Launcher::OnTooltipVisible(nux::ObjectPtr<nux::View> view)
+{
+  _active_tooltip = view;
+}
+
 void Launcher::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
 

=== modified file 'plugins/unityshell/src/Launcher.h'
--- plugins/unityshell/src/Launcher.h	2012-04-17 05:29:12 +0000
+++ plugins/unityshell/src/Launcher.h	2012-07-26 05:12:23 +0000
@@ -99,6 +99,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);
@@ -276,6 +278,7 @@
   void OnOrderChanged();
 
   void OnIconNeedsRedraw(AbstractLauncherIcon::Ptr icon);
+  void OnTooltipVisible(nux::ObjectPtr<nux::View> view);
 
   void OnOverlayHidden(GVariant* data);
   void OnOverlayShown(GVariant* data);
@@ -314,6 +317,7 @@
 
   void DndReset();
   void DndHoveredIconReset();
+  nux::ObjectPtr<nux::View> _active_tooltip;
 
   nux::HLayout* m_Layout;
 

=== modified file 'plugins/unityshell/src/LauncherIcon.cpp'
--- plugins/unityshell/src/LauncherIcon.cpp	2012-07-16 11:03:18 +0000
+++ plugins/unityshell/src/LauncherIcon.cpp	2012-07-26 05:12:23 +0000
@@ -524,6 +524,7 @@
     LoadTooltip();
   _tooltip->ShowTooltipWithTipAt(tip_x, tip_y);
   _tooltip->ShowWindow(!tooltip_text().empty());
+  tooltip_visible.emit(_tooltip);
 }
 
 void
@@ -545,6 +546,7 @@
 
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 bool LauncherIcon::OpenQuicklist(bool select_first_item, int monitor)
@@ -663,6 +665,7 @@
 {
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 gboolean

=== modified file 'plugins/unityshell/src/PanelController.cpp'
--- plugins/unityshell/src/PanelController.cpp	2012-04-04 20:21:45 +0000
+++ plugins/unityshell/src/PanelController.cpp	2012-07-26 05:12:23 +0000
@@ -48,6 +48,7 @@
   void QueueRedraw();
 
   std::vector<Window> GetTrayXids() const;
+  std::vector<nux::View*> GetPanelViews() const;
   std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
@@ -111,6 +112,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;
@@ -337,6 +347,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 'plugins/unityshell/src/PanelController.h'
--- plugins/unityshell/src/PanelController.h	2012-04-02 14:02:29 +0000
+++ plugins/unityshell/src/PanelController.h	2012-07-26 05:12:23 +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-07-13 17:56:23 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-07-26 05:12:23 +0000
@@ -115,8 +115,8 @@
   , _redraw_handle(0)
   , newFocusedWindow(nullptr)
   , doShellRepaint(false)
+  , didShellRepaint(false)
   , allowWindowPaint(false)
-  , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
 #ifndef USE_GLES
@@ -911,13 +911,14 @@
   }
 
   doShellRepaint = false;
-  damaged = false;
+  didShellRepaint = true;
 }
 
 bool UnityScreen::forcePaintOnTop ()
 {
     return !allowWindowPaint ||
-      ((switcher_controller_->Visible() || launcher_controller_->IsOverlayOpen())
+      ((switcher_controller_->Visible() ||
+        PluginAdapter::Default()->IsExpoActive())
        && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
 }
 
@@ -1204,6 +1205,42 @@
   }
 }
 
+bool UnityScreen::shellCouldBeHidden(CompOutput const& output)
+{
+  std::vector<Window> const& nuxwins(nux::XInputWindow::NativeHandleList());
+
+  // Loop through windows from front to back
+  CompWindowList const& wins = screen->windows();
+  for ( CompWindowList::const_reverse_iterator r = wins.rbegin()
+      ; r != wins.rend()
+      ; r++
+      )
+  {
+    CompWindow* w = *r;
+
+    /*
+     * The shell is hidden if there exists any window that fully covers
+     * the output and is in front of all Nux windows on that output.
+     */
+    if (w->isMapped() &&
+        !(w->state () & CompWindowStateHiddenMask) &&
+        w->geometry().contains(output))
+    {
+      return true;
+    }
+    else
+    {
+      for (Window n : nuxwins)
+      {
+        if (w->id() == n && output.intersects(w->geometry()))
+          return false;
+      }
+    }
+  }
+
+  return false;
+}
+
 /* called whenever we need to repaint parts of the screen */
 bool UnityScreen::glPaintOutput(const GLScreenPaintAttrib& attrib,
                                 const GLMatrix& transform,
@@ -1213,7 +1250,20 @@
 {
   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();
+  doShellRepaint = force ||
+                   ( !region.isEmpty() &&
+                     ( !wt->GetDrawList().empty() ||
+                       (mask & PAINT_SCREEN_FULL_MASK)
+                     )
+                   );
+
   allowWindowPaint = true;
   _last_output = output;
   paint_panel_ = false;
@@ -1228,14 +1278,27 @@
    *   once an fbo is bound any further
    *   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 ()));
+   *   you always unbind as much as you bind
+   *
+   * But NOTE: It is only safe to bind the FBO if !shellCouldBeHidden.
+   *           Otherwise it's possible painting won't occur and that would
+   *           confuse the state of the FBO.
+   */
+  if (doShellRepaint && !shellCouldBeHidden(*output))
+    _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 #endif
 
+  // CompRegion has no clear() method. So this is the fastest alternative.
+  fullscreenRegion = 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_GLES
+  if (doShellRepaint && !force && fullscreenRegion.contains(*output))
+    doShellRepaint = false;
+
   if (doShellRepaint)
     paintDisplay(region, transform, mask);
 #endif
@@ -1288,16 +1351,26 @@
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
     wi->HandleAnimations (ms);
 
-  if (damaged)
-  {
-    damaged = false;
-    damageNuxRegions();
-  }
+  compizDamageNux(cScreen->currentDamage());
 
+  didShellRepaint = false;
+  firstWindowAboveShell = NULL;
 }
 
 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)
@@ -1318,35 +1391,116 @@
   cScreen->donePaint ();
 }
 
+void UnityScreen::compizDamageNux(CompRegion const& damage)
+{
+  if (!launcher_controller_)
+    return;
+
+  /*
+   * Prioritise user interaction over active blur updates. So the general
+   * slowness of the active blur doesn't affect the UI interaction performance.
+   *
+   * Also, BackgroundEffectHelper::ProcessDamage() is causing a feedback loop
+   * while the dash is open. Calling it results in the NEXT frame (and the
+   * current one?) to get some damage. This GetDrawList().empty() check avoids
+   * that feedback loop and allows us to idle correctly.
+   */
+  if (wt->GetDrawList().empty())
+  {
+    CompRect::vector const& rects(damage.rects());
+    for (CompRect const& 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()
 {
+  /*
+   * WARNING: Nux bug LP: #1014610 (unbounded DrawList growth) will cause
+   *          this code to be called far too often in some cases and
+   *          Unity will appear to freeze for a while. Please ensure you
+   *          have Nux 3.0+ with the fix for LP: #1014610.
+   */
+
+  if (!launcher_controller_ || !dash_controller_)
+    return;
+
   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);
+  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);
-
-  wt->ClearDrawList();
-
-  lastTooltipArea = geo;
+  cScreen->damageRegionSetEnabled(this, true);
 }
 
 /* handle X Events */
@@ -1502,44 +1656,12 @@
   {
     wt->ProcessForeignEvent(event, NULL);
   }
-
-  if (event->type == cScreen->damageEvent() + XDamageNotify)
-  {
-    XDamageNotifyEvent *de = (XDamageNotifyEvent *) event;
-    CompWindow* w = screen->findWindow (de->drawable);
-    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
-    CompWindow* lastNWindow = screen->findWindow (xwns.back ());
-    bool        processDamage = true;
-
-    if (w)
-    {
-      if (!w->overrideRedirect () &&
-          w->isViewable () &&
-          !w->invisible ())
-      {
-
-        for (; lastNWindow != NULL; lastNWindow = lastNWindow->next)
-        {
-          if (lastNWindow == w)
-          {
-            processDamage = false;
-            break;
-          }
-        }
-
-        if (processDamage)
-        {
-          nux::Geometry damage (de->area.x, de->area.y, de->area.width, de->area.height);
-
-          const CompWindow::Geometry &geom = w->geometry ();
-          damage.x += geom.x () + geom.border ();
-          damage.y += geom.y () + geom.border ();
-
-          BackgroundEffectHelper::ProcessDamage(damage);
-        }
-      }
-    }
-  }
+}
+
+void UnityScreen::damageRegion(const CompRegion &region)
+{
+  compizDamageNux(region);
+  cScreen->damageRegion(region);
 }
 
 void UnityScreen::handleCompizEvent(const char* plugin,
@@ -2195,14 +2317,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();
@@ -2227,6 +2341,42 @@
                           const CompRegion& region,
                           unsigned int mask)
 {
+  /*
+   * The occlusion pass tests windows from TOP to BOTTOM. That's opposite to
+   * the actual painting loop.
+   *
+   * Detect uScreen->fullscreenRegion here. That represents the region which
+   * fully covers the shell on its output. It does not include regular windows
+   * stacked above the shell like DnD icons or Onboard etc.
+   */
+  if (isNuxWindow(window))
+  {
+    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+    {
+      uScreen->nuxRegion += window->geometry();
+      uScreen->nuxRegion -= uScreen->fullscreenRegion;
+    }
+    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) &&
+        (window->state() & CompWindowStateFullscreenMask))
+        // 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->fullscreenRegion += window->geometry();
+      uScreen->fullscreenRegion -= uScreen->nuxRegion;
+    }
+    if (uScreen->nuxRegion.isEmpty())
+      uScreen->firstWindowAboveShell = window;
+  }
+
   GLWindowPaintAttrib wAttrib = attrib;
 
   if (mMinimizeHandler)
@@ -2285,28 +2435,17 @@
     }
   }
 
-  if (uScreen->doShellRepaint && !uScreen->forcePaintOnTop ())
+  if (uScreen->doShellRepaint &&
+      !uScreen->forcePaintOnTop () &&
+      window == uScreen->firstWindowAboveShell &&
+      !uScreen->fullscreenRegion.contains(window->geometry())
+     )
   {
-    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_GLES
-          uScreen->paintDisplay();
+    uScreen->paintDisplay();
 #else
-          uScreen->paintDisplay(region, matrix, mask);
+    uScreen->paintDisplay(region, matrix, mask);
 #endif
-          break;
-        }
-      }
-    }
   }
 
   if (window->type() == CompWindowTypeDesktopMask)
@@ -2611,17 +2750,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 (!_redraw_handle)
-      _redraw_handle = g_idle_add_full (G_PRIORITY_DEFAULT, &UnityScreen::OnRedrawTimeout, this, NULL);
-  }
-  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-27 01:19:32 +0000
+++ plugins/unityshell/src/unityshell.h	2012-07-26 05:12:23 +0000
@@ -111,6 +111,9 @@
                      const char         *eventName,
                      CompOption::Vector &o);
 
+  void damageRegion(const CompRegion &region);
+
+  bool shellCouldBeHidden(CompOutput const& output);
 
   /* paint on top of all windows if we could not find a window
    * to paint underneath */
@@ -132,9 +135,6 @@
                                 CompOutput*,
                                 unsigned int);
 
-  /* Pop our InputOutput windows from the paint list */
-  const CompWindowList& getWindowPaintList();
-
   /* handle X11 events */
   void handleEvent(XEvent*);
 
@@ -211,7 +211,10 @@
 
   static gboolean initPluginActions(gpointer data);
   void initLauncher();
-  void damageNuxRegions();
+
+  void compizDamageNux(CompRegion const& region);
+  void nuxDamageCompiz();
+
   void onRedrawRequested();
   void Relayout();
 
@@ -261,7 +264,6 @@
   bool enable_shortcut_overlay_;
 
   std::unique_ptr<GestureEngine>        gesture_engine_;
-  nux::Geometry                         lastTooltipArea;
   bool                                  needsRelayout;
   bool                                  _in_paint;
   guint32                               relayoutSourceId;
@@ -280,11 +282,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 fullscreenRegion;
+  CompWindow* firstWindowAboveShell;
 
   nux::Property<nux::Geometry> primary_monitor_;