Merge lp:~compiz-team/compiz/compiz.fix_1171314 into lp:compiz/0.9.10

[Sam Spilsbury]

Don't add the frame to the toplevel stack if it hasn't been created yet.

In the event that a window is unreparented or destroyed, we usually need
to add its frame window to the toplevel window stack until the time at
which we recieve a DestroyNotify for it, as there may be incoming
ConfigureNotify events puporting to stack other windows relative to
that frame.

However, this does not apply in the case where we have not yet received
a CreateNotify for the frame window. In that case, it is not possible
for any stacking requests to be made relative to this window, so it
does not need to be added immediately. Instead, we can add it at the
time that we recieve a CreateNotify for it as a regular override
redirect window until the time that it is later destroyed.

(LP: #1171314)

Don't add the frame to the toplevel stack if it hasn't been created yet.

In the event that a window is unreparented or destroyed, we usually need
to add its frame window to the toplevel window stack until the time at
which we recieve a DestroyNotify for it, as there may be incoming
ConfigureNotify events puporting to stack other windows relative to
that frame.

However, this does not apply in the case where we have not yet received
a CreateNotify for the frame window. In that case, it is not possible
for any stacking requests to be made relative to this window, so it
does not need to be added immediately. Instead, we can add it at the
time that we recieve a CreateNotify for it as a regular override
redirect window until the time that it is later destroyed.

(LP: #1171314)

[lp:~compiz-team/compiz/compiz.fix_1171314]

3748. By Sam Spilsbury on 2013-06-26

Remove timeout

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3747
http://jenkins.qa.ubuntu.com/job/compiz-ci/215/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/256/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-amd64-ci/28
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-armhf-ci/28
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-i386-ci/28

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/215/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3748
http://jenkins.qa.ubuntu.com/job/compiz-ci/216/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-gles-ci/./build=pbuilder,distribution=raring,flavor=amd64/257/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-amd64-ci/29
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-armhf-ci/29
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-saucy-i386-ci/29

Click here to trigger a rebuild:
http://s-jenkins:8080/job/compiz-ci/216/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2013-03-06 12:31:24 +0000
+++ src/privatewindow.h	2013-06-26 11:06:25 +0000
@@ -252,6 +252,7 @@
 
 	bool reparent ();
 	void unreparent ();
+	void manageFrameWindowSeparately ();
 
 	void hide ();
 

=== modified file 'src/window.cpp'
--- src/window.cpp	2013-05-27 16:19:59 +0000
+++ src/window.cpp	2013-06-26 11:06:25 +0000
@@ -1189,33 +1189,7 @@
 	CompWindow *oldNext       = next;
 	CompWindow *oldPrev       = prev;
 
-	/* This is where things get tricky ... it is possible
-	 * to receive a ConfigureNotify relative to a frame window
-	 * for a destroyed window in case we process a ConfigureRequest
-	 * for the destroyed window and then a DestroyNotify for it directly
-	 * afterwards. In that case, we will receive the ConfigureNotify
-	 * for the XConfigureWindow request we made relative to that frame
-	 * window. Because of this, we must keep the frame window in the stack
-	 * as a new toplevel window so that the ConfigureNotify will be processed
-	 * properly until it too receives a DestroyNotify */
-
-	if (priv->serverFrame)
-	{
-	    XWindowAttributes attrib;
-
-	    /* It's possible that the frame window was already destroyed because
-	     * the client was unreparented before it was destroyed (eg
-	     * UnmapNotify before DestroyNotify). In that case the frame window
-	     * is going to be an invalid window but since we haven't received
-	     * a DestroyNotify for it yet, it is possible that restacking
-	     * operations could occurr relative to it so we need to hold it
-	     * in the stack for now. Ensure that it is marked override redirect */
-	    XGetWindowAttributes (screen->dpy (), priv->serverFrame, &attrib);
-
-	    /* Put the frame window "above" the client window
-	     * in the stack */
-	    PrivateWindow::createCompWindow (priv->id, priv->id, attrib, priv->serverFrame);
-	}
+	priv->manageFrameWindowSeparately ();
 
 	/* Immediately unhook the window once destroyed
 	 * as the stacking order will be invalid if we don't
@@ -6867,6 +6841,44 @@
 }
 
 void
+PrivateWindow::manageFrameWindowSeparately ()
+{
+    /* This is where things get tricky ... it is possible
+     * to receive a ConfigureNotify relative to a frame window
+     * for a destroyed window in case we process a ConfigureRequest
+     * for the destroyed window and then a DestroyNotify for it directly
+     * afterwards. In that case, we will receive the ConfigureNotify
+     * for the XConfigureWindow request we made relative to that frame
+     * window. Because of this, we must keep the frame window in the stack
+     * as a new toplevel window so that the ConfigureNotify will be processed
+     * properly until it too receives a DestroyNotify
+     *
+     * We only wish to do this if we have recieved a CreateNotify for the
+     * frame window. If we have not, then there will be no stacking operations
+     * dependent on it and we should wait until CreateNotify in order to manage
+     * it normally */
+
+    if (frame)
+    {
+	XWindowAttributes attrib;
+
+	/* It's possible that the frame window was already destroyed because
+	 * the client was unreparented before it was destroyed (eg
+	 * UnmapNotify before DestroyNotify). In that case the frame window
+	 * is going to be an invalid window but since we haven't received
+	 * a DestroyNotify for it yet, it is possible that restacking
+	 * operations could occurr relative to it so we need to hold it
+	 * in the stack for now. Ensure that it is marked override redirect */
+	window->priv->queryFrameAttributes (attrib);
+
+	/* Put the frame window "above" the client window
+	 * in the stack */
+	PrivateWindow::createCompWindow (id, id, attrib, frame);
+    }
+
+}
+
+void
 PrivateWindow::unreparent ()
 {
     if (!serverFrame)
@@ -6961,33 +6973,7 @@
     if (dbg)
 	dbg->addDestroyedFrame (serverFrame);
 
-    /* This is where things get tricky ... it is possible
-     * to receive a ConfigureNotify relative to a frame window
-     * for a destroyed window in case we process a ConfigureRequest
-     * for the destroyed window and then a DestroyNotify for it directly
-     * afterwards. In that case, we will receive the ConfigureNotify
-     * for the XConfigureWindow request we made relative to that frame
-     * window. Because of this, we must keep the frame window in the stack
-     * as a new toplevel window so that the ConfigureNotify will be processed
-     * properly until it too receives a DestroyNotify */
-
-    if (serverFrame)
-    {
-	XWindowAttributes attrib;
-
-	/* It's possible that the frame window was already destroyed because
-	 * the client was unreparented before it was destroyed (eg
-	 * UnmapNotify before DestroyNotify). In that case the frame window
-	 * is going to be an invalid window but since we haven't received
-	 * a DestroyNotify for it yet, it is possible that restacking
-	 * operations could occurr relative to it so we need to hold it
-	 * in the stack for now. Ensure that it is marked override redirect */
-	window->priv->queryFrameAttributes (attrib);
-
-	/* Put the frame window "above" the client window
-	 * in the stack */
-	PrivateWindow::createCompWindow (id, id, attrib, serverFrame);
-    }
+    manageFrameWindowSeparately ();
 
     /* Issue a DestroyNotify */
     XDestroyWindow (screen->dpy (), serverFrame);

=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp	2013-06-22 12:27:36 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_configure_window.cpp	2013-06-26 11:06:25 +0000
@@ -59,21 +59,7 @@
 Window GetTopParent (Display *display,
 		     Window w)
 {
-    Window rootReturn = 0;
-    Window parentReturn = w;
-    Window lastParent = 0;
-
-    do
-    {
-	lastParent = parentReturn;
-
-	parentReturn = ct::GetImmediateParent (display,
-					       lastParent,
-					       rootReturn);
-	
-    } while (parentReturn != rootReturn);
-
-    return lastParent;
+    return ct::GetTopmostNonRootParent (display, w);
 }
 
 bool QueryGeometry (Display *dpy,

=== modified file 'tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp'
--- tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2013-02-26 11:56:10 +0000
+++ tests/system/xorg-gtest/tests/compiz_xorg_gtest_test_window_stacking.cpp	2013-06-26 11:06:25 +0000
@@ -25,8 +25,13 @@
 #include <stdexcept>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+
+#include <boost/shared_array.hpp>
+#include <boost/bind.hpp>
+
 #include <xorg/gtest/xorg-gtest.h>
 #include <compiz-xorg-gtest.h>
+#include <compiz_xorg_gtest_communicator.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
@@ -36,6 +41,7 @@
 using ::testing::Matcher;
 
 namespace ct = compiz::testing;
+namespace ctm = compiz::testing::messages;
 
 class CompizXorgSystemStackingTest :
     public ct::AutostartCompizXorgSystemTest
@@ -429,3 +435,400 @@
     EXPECT_EQ (dock, (*it++));
     EXPECT_EQ (w1, (*it++));
 }
+
+class StackingSync :
+    public ct::AutostartCompizXorgSystemTestWithTestHelper
+{
+    public:
+
+	void SetUp ();
+};
+
+void
+StackingSync::SetUp ()
+{
+    ct::AutostartCompizXorgSystemTestWithTestHelper::SetUp ();
+
+    XSelectInput (Display (), DefaultRootWindow (Display ()), StructureNotifyMask |
+							      SubstructureNotifyMask);
+}
+
+namespace
+{
+    Window CreateAndWaitForCreation (Display *dpy)
+    {
+	Window w = ct::CreateNormalWindow (dpy);
+	Advance (dpy,
+		 ct::WaitForEventOfTypeOnWindow (dpy,
+						 DefaultRootWindow (dpy),
+						 CreateNotify,
+						 -1,
+						 -1));
+	return w;
+    }
+
+    Window CreateOverrideRedirectWindow (Display *dpy)
+    {
+	XSetWindowAttributes attrib;
+
+	attrib.override_redirect = true;
+
+	Window w =
+	    XCreateWindow (dpy, DefaultRootWindow (dpy),
+			   ct::WINDOW_X,
+			   ct::WINDOW_Y,
+			   ct::WINDOW_WIDTH,
+			   ct::WINDOW_HEIGHT,
+			   0,
+			   DefaultDepth (dpy, 0),
+			   InputOutput,
+			   DefaultVisual (dpy, DefaultScreen (dpy)),
+			   CWOverrideRedirect,
+			   &attrib);
+
+	XSelectInput (dpy, w, StructureNotifyMask);
+	return w;
+    }
+
+    Window MapAndWaitForParent (Display *dpy, Window w)
+    {
+	XMapRaised (dpy, w);
+
+	Advance (dpy,
+		 ct::WaitForEventOfTypeOnWindow (dpy,
+						 w,
+						 ReparentNotify,
+						 -1,
+						 -1));
+
+	return ct::GetTopmostNonRootParent (dpy, w);
+    }
+
+    void DestroyOnReparent (Display          *dpy,
+			    ct::MessageAtoms &atoms,
+			    Window           w)
+    {
+	Window root = DefaultRootWindow (dpy);
+	Atom   atom =
+	    atoms.FetchForString (ctm::TEST_HELPER_DESTROY_ON_REPARENT);
+
+	std::vector <long> data (4);
+
+	ct::SendClientMessage (dpy, atom, root, w, data);
+    }
+
+    Window WaitForNextCreatedWindow (Display *dpy)
+    {
+	XEvent ev;
+	while (true)
+	{
+	    XNextEvent (dpy, &ev);
+	    if (ev.type == CreateNotify)
+		return ev.xcreatewindow.window;
+	}
+
+	return 0;
+    }
+
+    void WaitForManage (Display          *dpy,
+			ct::MessageAtoms &atoms)
+    {
+	Atom   atom =
+	    atoms.FetchForString (ctm::TEST_HELPER_WINDOW_READY);
+	XEvent ev;
+
+	ct::ReceiveMessage (dpy, atom, ev);
+    }
+
+    void RestackAbove (Display *dpy,
+		       Window  w,
+		       Window  above)
+    {
+	XWindowChanges xwc;
+
+	xwc.stack_mode = Above;
+	xwc.sibling = above;
+
+	XConfigureWindow (dpy, w, CWStackMode | CWSibling, &xwc);
+    }
+
+    void RestackAtLeastAbove (Display          *dpy,
+			      ct::MessageAtoms &atoms,
+			      Window           w,
+			      Window           above)
+    {
+	Window root = DefaultRootWindow (dpy);
+	Atom   atom =
+	    atoms.FetchForString (ctm::TEST_HELPER_RESTACK_ATLEAST_ABOVE);
+
+	std::vector <long> data (4);
+
+	data[0] = above;
+	ct::SendClientMessage (dpy, atom, root, w, data);
+    }
+
+    void FreeWindowArray (Window *array)
+    {
+	XFree (array);
+    }
+
+    typedef boost::shared_array <Window> WindowArray;
+
+    WindowArray GetChildren (Display      *dpy,
+			     Window       w,
+			     unsigned int &n)
+    {
+	Window unused;
+	Window *children;
+
+	if (!XQueryTree (dpy, w, &unused, &unused, &children, &n))
+	    throw std::logic_error ("XQueryTree failed");
+
+	return WindowArray (children, boost::bind (FreeWindowArray, _1));
+    }
+
+    class StackPositionMatcher :
+	public MatcherInterface <Window>
+    {
+	public:
+
+	    StackPositionMatcher (const WindowArray &array,
+				  Window            cmp,
+				  unsigned int      n);
+
+	protected:
+
+	    bool MatchAndExplain (Window              window,
+				  MatchResultListener *listener) const;
+	    void DescribeTo (std::ostream *os) const;
+
+	private:
+
+	    virtual bool Compare (int lhsPos,
+				  int rhsPos) const = 0;
+	    virtual void ExplainCompare (std::ostream *os) const = 0;
+
+	    WindowArray  array;
+	    unsigned int arrayNum;
+	    Window       cmp;
+
+    };
+
+    StackPositionMatcher::StackPositionMatcher (const WindowArray &array,
+						Window            cmp,
+						unsigned int      n) :
+	array (array),
+	arrayNum (n),
+	cmp (cmp)
+    {
+    }
+
+    bool
+    StackPositionMatcher::MatchAndExplain (Window window,
+					   MatchResultListener *listener) const
+    {
+	int lhsPos = -1, rhsPos = -1;
+
+	for (unsigned int i = 0; i < arrayNum; ++i)
+	{
+	    if (array[i] == window)
+		lhsPos = i;
+	    if (array[i] == cmp)
+		rhsPos = i;
+	}
+
+	if (lhsPos > -1 &&
+	    rhsPos > -1)
+	{
+	    if (Compare (lhsPos, rhsPos))
+		return true;
+	}
+
+	/* Match failed, add stack to MatchResultListener */
+	if (listener->IsInterested ())
+	{
+	    std::stringstream windowStack;
+
+	    windowStack << "Window Stack (bottom to top ["
+			<< arrayNum
+			<< "]): \n";
+	    *listener << windowStack.str ();
+	    for (unsigned int i = 0; i < arrayNum; ++i)
+	    {
+		std::stringstream ss;
+		ss << " - 0x"
+		   << std::hex
+		   << array[i]
+		   << std::dec
+		   << std::endl;
+		*listener << ss.str ();
+	    }
+
+	    std::stringstream lhsPosMsg, rhsPosMsg;
+
+	    lhsPosMsg << "Position of 0x"
+		      << std::hex
+		      << window
+		      << std::dec
+		      << " : "
+		      << lhsPos;
+
+	    rhsPosMsg << "Position of 0x"
+		      << std::hex
+		      << cmp
+		      << std::dec
+		      << " : "
+		      << rhsPos;
+
+	    *listener << lhsPosMsg.str () << "\n";
+	    *listener << rhsPosMsg.str () << "\n";
+	}
+
+	return false;
+    }
+
+    void
+    StackPositionMatcher::DescribeTo (std::ostream *os) const
+    {
+	*os << "Window is ";
+	ExplainCompare (os);
+	*os << " in relation to 0x" << std::hex << cmp << std::dec;
+    }
+
+    class GreaterThanInStackMatcher :
+	public StackPositionMatcher
+    {
+	public:
+
+	    GreaterThanInStackMatcher (const WindowArray &array,
+				       Window            cmp,
+				       unsigned int      n);
+
+	private:
+
+	    bool Compare (int lhsPos, int rhsPos) const;
+	    void ExplainCompare (std::ostream *os) const;
+    };
+
+    GreaterThanInStackMatcher::GreaterThanInStackMatcher (const WindowArray &array,
+							  Window            cmp,
+							  unsigned int      n) :
+	StackPositionMatcher (array, cmp, n)
+    {
+    }
+
+    bool GreaterThanInStackMatcher::Compare (int lhsPos, int rhsPos) const
+    {
+	return lhsPos > rhsPos;
+    }
+
+    void GreaterThanInStackMatcher::ExplainCompare (std::ostream *os) const
+    {
+	*os << "greater than";
+    }
+
+    class LessThanInStackMatcher :
+	public StackPositionMatcher
+    {
+	public:
+
+	    LessThanInStackMatcher (const WindowArray &array,
+				    Window            cmp,
+				    unsigned int      n);
+
+	private:
+
+	    bool Compare (int lhsPos, int rhsPos) const;
+	    void ExplainCompare (std::ostream *os) const;
+    };
+
+    LessThanInStackMatcher::LessThanInStackMatcher (const WindowArray &array,
+						    Window            cmp,
+						    unsigned int      n) :
+	StackPositionMatcher (array, cmp, n)
+    {
+    }
+
+    bool LessThanInStackMatcher::Compare (int lhsPos, int rhsPos) const
+    {
+	return lhsPos < rhsPos;
+    }
+
+    void LessThanInStackMatcher::ExplainCompare (std::ostream *os) const
+    {
+	*os << "less than";
+    }
+
+    inline Matcher <Window> GreaterThanInStack (const WindowArray &array,
+						unsigned int      n,
+						Window            cmp)
+    {
+	return MakeMatcher (new GreaterThanInStackMatcher (array, cmp, n));
+    }
+
+    inline Matcher <Window> LessThanInStack (const WindowArray &array,
+					     unsigned int      n,
+					     Window            cmp)
+    {
+	return MakeMatcher (new LessThanInStackMatcher (array, cmp, n));
+    }
+}
+
+TEST_F (StackingSync, DestroyClientJustBeforeReparent)
+{
+    ::Display *dpy = Display ();
+
+    ct::MessageAtoms atoms (dpy);
+
+    /* Set up three normal windows */
+    Window w1 = CreateAndWaitForCreation (dpy);
+    Window w2 = CreateAndWaitForCreation (dpy);
+    Window w3 = CreateAndWaitForCreation (dpy);
+
+    Window p1 = MapAndWaitForParent (dpy, w1);
+    Window p2 = MapAndWaitForParent (dpy, w2);
+    Window p3 = MapAndWaitForParent (dpy, w3);
+
+    /* Create another normal window, but immediately mark
+     * it destroyed within compiz as soon as it is reparented,
+     * so that we force the reparented-but-destroyed strategy
+     * to kick in */
+    Window destroyed = CreateAndWaitForCreation (dpy);
+
+    DestroyOnReparent (dpy, atoms, destroyed);
+    XMapRaised (dpy, destroyed);
+
+    /* Wait for the destroyed window's parent to be created
+     * in the toplevel stack as a result of the reparent operation */
+    Window parentOfDestroyed = WaitForNextCreatedWindow (dpy);
+    WaitForManage (dpy, atoms);
+
+    /* Create an override redirect window and wait for it to be
+     * managed */
+    Window override = CreateOverrideRedirectWindow (dpy);
+    WaitForManage (dpy, atoms);
+
+    /* Place the destroyed window's parent above
+     * p1 in the stack directly */
+    RestackAbove (dpy, parentOfDestroyed, p1);
+
+    /* Ask compiz to place the override redirect window
+     * at least above the destroyed window's parent
+     * in the stack. This requires compiz to locate the
+     * destroyed window's parent in the stack */
+    RestackAtLeastAbove (dpy, atoms, override, parentOfDestroyed);
+
+    /* Wait for the override window to be configured */
+    Advance (dpy,
+	     ct::WaitForEventOfTypeOnWindow (dpy,
+					     override,
+					     ConfigureNotify,
+					     -1,
+					     -1));
+
+    unsigned int n;
+    WindowArray  windows (GetChildren (dpy, DefaultRootWindow (dpy), n));
+
+    EXPECT_THAT (p2, LessThanInStack (windows, n, override));
+    EXPECT_THAT (p3, GreaterThanInStack (windows, n, override));
+}

=== modified file 'tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp'
--- tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp	2013-02-23 07:08:20 +0000
+++ tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.cpp	2013-06-26 11:06:25 +0000
@@ -50,6 +50,8 @@
     "_COMPIZ_TEST_HELPER_FRAME_EXTENTS_CHANGED",
     "_COMPIZ_TEST_HELPER_CONFIGURE_WINDOW",
     "_COMPIZ_TEST_HELPER_WINDOW_CONFIGURE_PROCESSED",
+    "_COMPIZ_TEST_HELPER_DESTROY_ON_REPARENT",
+    "_COMPIZ_TEST_HELPER_RESTACK_ATLEAST_ABOVE",
     "_COMPIZ_TEST_HELPER_WINDOW_READY"
 };
 }
@@ -61,7 +63,9 @@
 const char *TEST_HELPER_FRAME_EXTENTS_CHANGED = internal::messages[4];
 const char *TEST_HELPER_CONFIGURE_WINDOW = internal::messages[5];
 const char *TEST_HELPER_WINDOW_CONFIGURE_PROCESSED = internal::messages[6];
-const char *TEST_HELPER_WINDOW_READY = internal::messages[7];
+const char *TEST_HELPER_DESTROY_ON_REPARENT = internal::messages[7];
+const char *TEST_HELPER_RESTACK_ATLEAST_ABOVE = internal::messages[8];
+const char *TEST_HELPER_WINDOW_READY = internal::messages[9];
 }
 }
 }

=== modified file 'tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h'
--- tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h	2013-02-23 07:08:20 +0000
+++ tests/xorg-gtest/communicator/compiz_xorg_gtest_communicator.h	2013-06-26 11:06:25 +0000
@@ -41,6 +41,8 @@
 extern const char *TEST_HELPER_FRAME_EXTENTS_CHANGED;
 extern const char *TEST_HELPER_CONFIGURE_WINDOW;
 extern const char *TEST_HELPER_WINDOW_CONFIGURE_PROCESSED;
+extern const char *TEST_HELPER_DESTROY_ON_REPARENT;
+extern const char *TEST_HELPER_RESTACK_ATLEAST_ABOVE;
 extern const char *TEST_HELPER_WINDOW_READY;
 }
 

=== modified file 'tests/xorg-gtest/include/compiz-xorg-gtest.h'
--- tests/xorg-gtest/include/compiz-xorg-gtest.h	2013-06-22 12:27:36 +0000
+++ tests/xorg-gtest/include/compiz-xorg-gtest.h	2013-06-26 11:06:25 +0000
@@ -125,6 +125,8 @@
 	Window GetImmediateParent (Display *display,
 				   Window  w,
 				   Window  &rootReturn);
+	Window GetTopmostNonRootParent (Display *display,
+					Window  w);
 
 	std::list <Window> NET_CLIENT_LIST_STACKING (Display *);
 	bool AdvanceToNextEventOnSuccess (Display *dpy,

=== modified file 'tests/xorg-gtest/plugins/testhelper/src/testhelper.cpp'
--- tests/xorg-gtest/plugins/testhelper/src/testhelper.cpp	2013-05-09 13:43:07 +0000
+++ tests/xorg-gtest/plugins/testhelper/src/testhelper.cpp	2013-06-26 11:06:25 +0000
@@ -181,10 +181,66 @@
     }
 }
 
+void
+TestHelperWindow::setDestroyOnReparent (long *)
+{
+    destroyOnReparent = true;
+}
+
+void
+TestHelperWindow::restackAtLeastAbove (long *data)
+{
+    ServerLock lock (screen->serverGrabInterface ());
+
+    Window            above = data[0];
+    XWindowAttributes attrib;
+
+    if (!XGetWindowAttributes (screen->dpy (), above, &attrib))
+	return;
+
+    CompWindow *w = screen->findTopLevelWindow (above, true);
+    for (; w; w = w->next)
+	if (!w->overrideRedirect ())
+	    break;
+
+    if (!w)
+	return;
+
+    XWindowChanges xwc;
+
+    xwc.stack_mode = Above;
+    xwc.sibling = w->frame () ? w->frame () : w->id ();
+
+    window->restackAndConfigureXWindow (CWStackMode | CWSibling,
+					&xwc,
+					lock);
+}
+
+void
+TestHelperWindow::windowNotify (CompWindowNotify n)
+{
+    switch (n)
+    {
+	case CompWindowNotifyReparent:
+	    if (destroyOnReparent)
+	    {
+		Window id = window->id ();
+		window->destroy ();
+		XDestroyWindow (screen->dpy (), id);
+	    }
+	    break;
+	default:
+	    break;
+    }
+
+    window->windowNotify (n);
+}
+
 TestHelperWindow::TestHelperWindow (CompWindow *w) :
     PluginClassHandler <TestHelperWindow, CompWindow> (w),
     window (w),
-    configureLock ()
+    configureLock (),
+    destroyOnReparent (false)
 {
     WindowInterface::setHandler (w);
 
@@ -214,6 +270,10 @@
 		     &TestHelperWindow::setFrameExtentsAndReport);
     watchForMessage (fetchAtom (ctm::TEST_HELPER_LOCK_CONFIGURE_REQUESTS),
 		     &TestHelperWindow::setConfigureLock);
+    watchForMessage (fetchAtom (ctm::TEST_HELPER_DESTROY_ON_REPARENT),
+		     &TestHelperWindow::setDestroyOnReparent);
+    watchForMessage (fetchAtom (ctm::TEST_HELPER_RESTACK_ATLEAST_ABOVE),
+		     &TestHelperWindow::restackAtLeastAbove);
 
     ct::SendClientMessage (s->dpy (),
 			   mAtomStore.FetchForString (ctm::TEST_HELPER_READY_MSG),

=== modified file 'tests/xorg-gtest/plugins/testhelper/src/testhelper.h'
--- tests/xorg-gtest/plugins/testhelper/src/testhelper.h	2013-02-14 12:12:53 +0000
+++ tests/xorg-gtest/plugins/testhelper/src/testhelper.h	2013-06-26 11:06:25 +0000
@@ -77,11 +77,17 @@
 	void configureAndReport (long *);
 	void setFrameExtentsAndReport (long *);
 	void setConfigureLock (long *);
+	void setDestroyOnReparent (long *);
+	void restackAtLeastAbove (long *);
 
     private:
 
+	void windowNotify (CompWindowNotify n);
+
 	CompWindow                                         *window;
 	compiz::window::configure_buffers::Releasable::Ptr configureLock;
+
+	bool destroyOnReparent;
 };
 
 class TestHelperPluginVTable :

=== modified file 'tests/xorg-gtest/src/compiz-xorg-gtest.cpp'
--- tests/xorg-gtest/src/compiz-xorg-gtest.cpp	2013-06-22 12:27:36 +0000
+++ tests/xorg-gtest/src/compiz-xorg-gtest.cpp	2013-06-26 11:06:25 +0000
@@ -105,6 +105,27 @@
     return parentReturn;
 }
 
+Window
+ct::GetTopmostNonRootParent (Display *display,
+			     Window  w)
+{
+    Window rootReturn = 0;
+    Window parentReturn = w;
+    Window lastParent = 0;
+
+    do
+    {
+	lastParent = parentReturn;
+
+	parentReturn = GetImmediateParent (display,
+					   lastParent,
+					   rootReturn);
+
+    } while (parentReturn != rootReturn);
+
+    return lastParent;
+}
+
 bool
 ct::AdvanceToNextEventOnSuccess (Display *dpy,
 				 bool waitResult)