Merge lp:~compiz-team/compiz-core/compiz-core.fix_860304 into lp:compiz-core/0.9.5

[Sam Spilsbury]

Fix bug 860304

[Robert Carr (robertcarr)]

+1

review: Approve

[David Barth (dbarth)]

The code changes are massive: is that some parts that you've taken from elsewhere and can be trusted to be well tested already? Or is it all brand new code? The worst would be to add crashers.

[lp:~compiz-team/compiz-core/compiz-core.fix_860304]

2840. By Sam Spilsbury on 2011-09-27

Fix typoes

2841. By Sam Spilsbury on 2011-09-27

Added a workaround to ensure that we don't end up with stale configure requests
causing windows to always be moved asynchronously (slow)

[Carey Underwood (cwillu)]

Something in this appears to have made moving windows quite slow, and frequently preventing the window (or any other windows for that matter) from updating while the mouse is still moving. Enabling sync to vrefresh makes it much worse. Disabling the unityshell plugin temporarily immediately restores silky smooth behaviour.

=== modified file 'plugins/move/src/move.cpp'
--- plugins/move/src/move.cpp	2011-06-23 03:22:47 +0000
+++ plugins/move/src/move.cpp	2011-09-27 15:45:28 +0000
@@ -488,7 +488,8 @@
 		     wY + dy - w->geometry ().y (), false);
 
 	    if (ms->optionGetLazyPositioning () &&
-	        MoveScreen::get (screen)->hasCompositing)
+		ms->hasCompositing &&
+		!MoveWindow::get (ms->w)->mLocked)
 	    {
 		/* FIXME: This form of lazy positioning is broken and should
 		   be replaced asap. Current code exists just to avoid a
@@ -507,6 +508,32 @@
     }
 }
 
+/* FIXME: This is a hack to prevent a race condition
+ * when core is processing ConfigureNotify events. It
+ * MUST be removed after 0.9.6 when we can break ABI
+ * and do lazy positioning correctly ! */
+
+void
+MoveScreen::handleCompizEvent (const char *plugin, const char *event, CompOption::Vector &options)
+{
+    if (w)
+    {
+	if (std::string ("core") == std::string (plugin))
+	{
+	    if (std::string ("lock_position") == std::string (event))
+	    {
+		Window xid = CompOption::getIntOptionNamed (options, "window", 0);
+		int    lock = CompOption::getIntOptionNamed (options, "active", 0);
+
+		if (xid == w->id ())
+		    MoveWindow::get (w)->mLocked = lock ? true : false;
+	    }
+	}
+    }
+
+    screen->handleCompizEvent (plugin, event, options);
+}
+
 void
 MoveScreen::handleEvent (XEvent *event)
 {
 
=== modified file 'plugins/move/src/move.h'
--- plugins/move/src/move.h	2009-12-25 19:49:23 +0000
+++ plugins/move/src/move.h	2011-09-27 15:45:28 +0000
@@ -61,6 +61,9 @@
 	void updateOpacity ();
 
 	void handleEvent (XEvent *);
+	void handleCompizEvent (const char *plugin,
+				const char *event,
+				CompOption::Vector &options);
 
 	CompWindow *w;
 	int        savedX;
@@ -98,7 +101,8 @@
 	    PluginClassHandler<MoveWindow,CompWindow> (window),
 	    window (window),
 	    gWindow (GLWindow::get (window)),
-	    cWindow (CompositeWindow::get (window))
+	    cWindow (CompositeWindow::get (window)),
+	    mLocked (false)
 	{
 	    if (gWindow)
 		GLWindowInterface::setHandler (gWindow, false);
@@ -110,6 +114,8 @@
 	CompWindow      *window;
 	GLWindow        *gWindow;
 	CompositeWindow *cWindow;
+
+	bool            mLocked;
 };
 
 #define MOVE_SCREEN(s) \
 
=== modified file 'src/privatewindow.h'
--- src/privatewindow.h	2011-09-25 04:16:18 +0000
+++ src/privatewindow.h	2011-09-27 15:45:28 +0000
@@ -211,6 +211,8 @@
 
 	void readIconHint ();
 
+	void addPendingConfigure (XWindowChanges &, unsigned int);
+
     public:
 
 	PrivateWindow *priv;
@@ -235,6 +237,8 @@
 	XWindowAttributes    attrib;
 	CompWindow::Geometry geometry;
 	CompWindow::Geometry serverGeometry;
+	CompWindow::Geometry frameGeometry;
+	CompWindow::Geometry serverFrameGeometry;
 	Window               transientFor;
 	Window               clientLeader;
 	XSizeHints	     sizeHints;
@@ -286,6 +290,11 @@
 	int pendingUnmaps;
 	int pendingMaps;
 
+	typedef std::pair <XWindowChanges, unsigned int> XWCValueMask;
+
+	std::list <XWCValueMask> pendingConfigures;
+	bool pendingPositionUpdates;
+
 	char *startupId;
 	char *resName;
 	char *resClass;
 
=== modified file 'src/screen.cpp'
--- src/screen.cpp	2011-09-25 04:16:18 +0000
+++ src/screen.cpp	2011-09-27 15:45:28 +0000
@@ -765,7 +765,7 @@
 		compLogMessage ("core", CompLogLevelDebug, "however, this may be a false positive");
 	}
 
-	if (dbg->serverWindowsChanged () && dbg->checkSanity (priv->serverWindows))
+	if (dbg->serverWindowsChanged () && dbg->checkSanity (priv->windows))
 	    compLogMessage ("core", CompLogLevelDebug, "windows are stacked incorrectly");
     }
 }
@@ -1756,8 +1756,13 @@
 
 	    if (moveX != 0 || moveY != 0)
 	    {
-		w->move (moveX, moveY, true);
-		w->syncPosition ();
+		unsigned int valueMask = CWX | CWY;
+		XWindowChanges xwc;
+
+		xwc.x = w->serverGeometry ().x () + moveX;
+		xwc.y = w->serverGeometry ().y () + moveY;
+
+		w->configureXWindow (valueMask, &xwc);
 	    }
 	}
     }
@@ -3502,6 +3507,9 @@
 
     foreach (CompWindow *w, priv->windows)
     {
+	unsigned int valueMask = CWX | CWY;
+	XWindowChanges xwc;
+
 	if (w->onAllViewports ())
 	    continue;
 
@@ -3513,11 +3521,10 @@
 	if (w->saveMask () & CWY)
 	    w->saveWc ().y += pnt.y ();
 
-	/* move */
-	w->move (pnt.x (), pnt.y ());
+	xwc.x = w->serverGeometry ().x () + pnt.x ();
+	xwc.y = w->serverGeometry ().y () + pnt.y ();
 
-	if (sync)
-	    w->syncPosition ();
+	w->configureXWindow (valueMask, &xwc);
     }
 
     if (sync)
 
=== modified file 'src/stackdebugger.cpp'
--- src/stackdebugger.cpp	2011-09-25 04:16:18 +0000
+++ src/stackdebugger.cpp	2011-09-27 15:45:28 +0000
@@ -330,6 +330,10 @@
 	if (!w->managed ())
 	    continue;
 
+	/* ignore any windows that just got created */
+	if (!w->mapNum ())
+	    continue;
+
 	/* determine the current layer */
 	if (w->type () == CompWindowTypeDockMask)
 	{
 
=== modified file 'src/window.cpp'
--- src/window.cpp	2011-09-25 04:16:18 +0000
+++ src/window.cpp	2011-09-27 15:45:28 +0000
@@ -792,32 +792,60 @@
 void
 PrivateWindow::updateFrameWindow ()
 {
+    XWindowChanges xwc;
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight;
+
     if (!serverFrame)
 	return;
 
+
     gettimeofday (&lastConfigureRequest, NULL);
+    /* Flush any changes made to serverFrameGeometry or serverGeometry to the server
+     * since there is a race condition where geometries will go out-of-sync with
+     * window movement */
+
+    window->syncPosition ();
 
     if (serverInput.left || serverInput.right || serverInput.top || serverInput.bottom)
     {
-        int	   x, y, width, height;
 	int	   bw = serverGeometry.border () * 2;
 
-	x      = serverGeometry.x () - serverInput.left;
-	y      = serverGeometry.y () - serverInput.top;
-	width  = serverGeometry.width () + serverInput.left + serverInput.right + bw;
-	height = serverGeometry.height () + serverInput.top  + serverInput.bottom + bw;
+	xwc.x      = serverGeometry.x () - serverInput.left;
+	xwc.y      = serverGeometry.y () - serverInput.top;
+	xwc.width  = serverGeometry.width () + serverInput.left + serverInput.right + bw;
+	xwc.height = serverGeometry.height () + serverInput.top  + serverInput.bottom + bw;
 
 	if (shaded)
 	    height = serverInput.top + serverInput.bottom;
 
+	if (serverFrameGeometry.x () == xwc.x)
+	    valueMask &= ~(CWX);
+	else
+	    serverFrameGeometry.setX (xwc.x);
+
+	if (serverFrameGeometry.y ()  == xwc.y)
+	    valueMask &= ~(CWY);
+	else
+	    serverFrameGeometry.setY (xwc.y);
+
+	if (serverFrameGeometry.width () == xwc.width)
+	    valueMask &= ~(CWWidth);
+	else
+	    serverFrameGeometry.setWidth (xwc.width);
+
+	if (serverFrameGeometry.height () == xwc.height)
+	    valueMask &= ~(CWHeight);
+	else
+	    serverFrameGeometry.setHeight (xwc.height);
+
+	addPendingConfigure (xwc, valueMask);
+
+
 	/* Geometry is the same, so we're not going to get a ConfigureNotify
 	 * event when the window is configured, which means that other plugins
 	 * won't know that the client, frame and wrapper windows got shifted
 	 * around (and might result in display corruption, eg in OpenGL */
-	if (geometry.x () - input.left == x &&
-	    geometry.y () - input.top  == y &&
-	    geometry.width () + input.left + input.right + bw == width &&
-	    geometry.height () + input.top + input.bottom + bw == height)
+	if (valueMask == 0)
 	{
 	    XConfigureEvent xev;
 	    XWindowAttributes attrib;
@@ -876,8 +904,7 @@
 	    XSync (screen->dpy (), false);
 	}
 	else
-	    XMoveResizeWindow (screen->dpy (), serverFrame, x, y, width, height);
-
+	    XConfigureWindow (screen->dpy (), serverFrame, valueMask, &xwc);
 	if (shaded)
 	{
 	    XUnmapWindow (screen->dpy (), wrapper);
@@ -895,25 +922,44 @@
     }
     else
     {
-	int	   x, y, width, height;
 	int	   bw = serverGeometry.border () * 2;
 
-	x      = serverGeometry.x ();
-	y      = serverGeometry.y ();
-	width  = serverGeometry.width () + bw;
-	height = serverGeometry.height () + bw;
+	xwc.x      = serverGeometry.x ();
+	xwc.y      = serverGeometry.y ();
+	xwc.width  = serverGeometry.width () + bw;
+	xwc.height = serverGeometry.height () + bw;
 
 	if (shaded)
 	    height = 0;
 
+	if (serverFrameGeometry.x () == xwc.x)
+	    valueMask &= ~(CWX);
+	else
+	    serverFrameGeometry.setX (xwc.x);
+
+	if (serverFrameGeometry.y ()  == xwc.y)
+	    valueMask &= ~(CWY);
+	else
+	    serverFrameGeometry.setY (xwc.y);
+
+	if (serverFrameGeometry.width () == xwc.width)
+	    valueMask &= ~(CWWidth);
+	else
+	    serverFrameGeometry.setWidth (xwc.width);
+
+	if (serverFrameGeometry.height () == xwc.height)
+	    valueMask &= ~(CWHeight);
+	else
+	    serverFrameGeometry.setHeight (xwc.height);
+
+	addPendingConfigure (xwc, valueMask);
+
+
 	/* Geometry is the same, so we're not going to get a ConfigureNotify
 	 * event when the window is configured, which means that other plugins
 	 * won't know that the client, frame and wrapper windows got shifted
 	 * around (and might result in display corruption, eg in OpenGL */
-	if (geometry.x () - input.left == x &&
-	    geometry.y () - input.top  == y &&
-	    geometry.width () + input.left + input.right + bw == width &&
-	    geometry.height () + input.top + input.bottom + bw == height)
+	if (valueMask == 0)
 	{
 	    XConfigureEvent xev;
 	    XWindowAttributes attrib;
@@ -972,7 +1018,7 @@
 	    XSync (screen->dpy (), false);
 	}
 	else
-	    XMoveResizeWindow (screen->dpy (), serverFrame, x, y, width, height);
+	    XConfigureWindow (screen->dpy (), serverFrame, valueMask, &xwc);
 
 	if (shaded)
 	{
@@ -1753,8 +1799,6 @@
 	dwidth  = gm.width () - priv->geometry.width ();
 	dheight = gm.height () - priv->geometry.height ();
 
-	gettimeofday (&priv->lastGeometryUpdate, NULL);
-
 	priv->geometry.set (gm.x (), gm.y (),
 			    gm.width (), gm.height (),
 			    gm.border ());
@@ -1776,13 +1820,17 @@
 	dx = gm.x () - priv->geometry.x ();
 	dy = gm.y () - priv->geometry.y ();
 
-	/* Don't move the window here if a plugin has already updated
-	 * the geometry of that window after the last time the server
-	 * was sent a configure request since the configureNotify we
-	 * receieve here will be out of date. Instead wait for the plugin
-	 * to call syncPosition again */
-	if (TIMEVALDIFF (&priv->lastConfigureRequest, &priv->lastGeometryUpdate))
-	    move (dx, dy);
+	priv->geometry.setX (gm.x ());
+	priv->geometry.setY (gm.y ());
+
+	priv->region.translate (dx, dy);
+	priv->inputRegion.translate (dx, dy);
+	if (!priv->frameRegion.isEmpty ())
+	    priv->frameRegion.translate (dx, dy);
+
+	priv->invisible = WINDOW_INVISIBLE (priv);
+
+	moveNotify (dx, dy, true);
     }
 
     updateFrameRegion ();
@@ -1911,11 +1959,35 @@
 void
 PrivateWindow::configure (XConfigureEvent *ce)
 {
+    unsigned int valueMask = 0;
+
     if (priv->frame)
 	return;
 
+    /* remove configure event from pending configures */
+    if (priv->geometry.x () != ce->x)
+	valueMask |= CWX;
+
+    if (priv->geometry.y () != ce->y)
+	valueMask |= CWY;
+
+    if (priv->geometry.width () != ce->width)
+	valueMask |= CWWidth;
+
+    if (priv->geometry.height () != ce->height)
+	valueMask |= CWHeight;
+
+    if (priv->geometry.border () != ce->border_width)
+	valueMask |= CWBorderWidth;
+
+    if (ROOTPARENT (window->prev) != ce->above)
+	valueMask |= CWSibling | CWStackMode;
+
     priv->attrib.override_redirect = ce->override_redirect;
 
+    priv->frameGeometry.set (ce->x, ce->y, ce->width,
+			     ce->height, ce->border_width);
+
     if (priv->syncWait)
 	priv->syncGeometry.set (ce->x, ce->y, ce->width, ce->height,
 				ce->border_width);
@@ -1939,10 +2011,89 @@
 {
     int x, y, width, height;
     CompWindow	     *above;
+    unsigned int     valueMask = 0;
+    bool             handled = false;
 
     if (!priv->frame)
 	return;
 
+    /* remove configure event from pending configures */
+    if (priv->frameGeometry.x () != ce->x)
+	valueMask |= CWX;
+
+    if (priv->frameGeometry.y () != ce->y)
+	valueMask |= CWY;
+
+    if (priv->frameGeometry.width () != ce->width)
+	valueMask |= CWWidth;
+
+    if (priv->frameGeometry.height () != ce->height)
+	valueMask |= CWHeight;
+
+    if (priv->frameGeometry.border () != ce->border_width)
+	valueMask |= CWBorderWidth;
+
+    if (ROOTPARENT (window->prev) != ce->above)
+	valueMask |= CWSibling | CWStackMode;
+
+    for (std::list <XWCValueMask>::iterator it = pendingConfigures.begin ();
+	 it != pendingConfigures.end (); it++)
+    {
+	XWCValueMask &xwcvm = (*it);
+
+
+	if (xwcvm.second != valueMask)
+	{
+	    /* For stacking cases, if a client wants to raise or lower a window
+	     * then they don't need to specify CWSibling, so allow that to be
+	     * excluded in those cases */
+
+	    if (ce->above == ROOTPARENT (screen->windows ().back ()) ||
+		ce->above == 0)
+	    {
+		if ((xwcvm.second & ~(CWSibling) != valueMask))
+		    continue;
+	    }
+	    else
+		continue;
+	}
+
+	if (xwcvm.second & CWX && xwcvm.first.x != ce->x)
+	    continue;
+
+	if (xwcvm.second & CWY && xwcvm.first.y != ce->y)
+	    continue;
+
+	if (xwcvm.second & CWWidth && xwcvm.first.width != ce->width)
+	    continue;
+
+	if (xwcvm.second & CWHeight && xwcvm.first.height != ce->height)
+	    continue;
+
+	if (xwcvm.second & (CWStackMode | CWSibling) && xwcvm.first.sibling != ce->above)
+	    continue;
+
+	/* Matched ConfigureWindow request to ConfigureNotify event
+	 * remove it from the list */
+
+	handled = true;
+
+	pendingConfigures.erase (it);
+	break;
+    }
+
+    if (!handled)
+    {
+	compLogMessage ("core", CompLogLevelWarn, "unhandled ConfigureNotify on 0x%x!", serverFrame);
+	compLogMessage ("core", CompLogLevelWarn, "this should never happen. you should"\
+						  "probably file a bug about this.");
+#ifdef DEBUG
+	abort ();
+#else
+	pendingConfigures.clear ();
+#endif
+    }
+
     /* subtract the input extents last sent to the
      * server to calculate the client size and then
      * re-sync the input extents and extents last
@@ -1953,19 +2104,14 @@
     width  = ce->width - priv->serverGeometry.border () * 2 - priv->serverInput.left - priv->serverInput.right;
     height = ce->height - priv->serverGeometry.border () * 2 - priv->serverInput.top - priv->serverInput.bottom;
 
+    /* set the frame geometry */
+    priv->frameGeometry.set (ce->x, ce->y, ce->width, ce->height, ce->border_width);
+
+
     if (priv->syncWait)
-    {
 	priv->syncGeometry.set (x, y, width, height, ce->border_width);
-    }
     else
-    {
-	if (ce->override_redirect)
-	{
-	    priv->serverGeometry.set (x, y, width, height, ce->border_width);
-	}
-
 	window->resize (x, y, width, height, ce->border_width);
-    }
 
     if (priv->restack (ce->above))
 	priv->updatePassiveButtonGrabs ();
@@ -1974,6 +2120,27 @@
 
     if (above)
 	above->priv->updatePassiveButtonGrabs ();
+
+    if (pendingConfigures.empty ())
+    {
+	/* Tell plugins its ok to start doing stupid things again but
+	 * obviously FIXME */
+	CompOption::Vector options;
+	CompOption::Value  v;
+
+	options.push_back (CompOption ("window", CompOption::TypeInt));
+	v.set ((int) id);
+	options.back ().set (v);
+	options.push_back (CompOption ("active", CompOption::TypeInt));
+	v.set ((int) 0);
+	options.back ().set (v);
+
+	/* Notify other plugins that it is unsafe to change geometry or serverGeometry
+	 * FIXME: That API should not be accessible to plugins, this is a hack to avoid
+	 * breaking ABI */
+
+	screen->handleCompizEvent ("core", "lock_position", options);
+    }
 }
 
 void
@@ -1996,43 +2163,129 @@
 {
     if (dx || dy)
     {
-	/*
-	priv->attrib.x += dx;
-	priv->attrib.y += dy;
-	*/
-	priv->geometry.setX (priv->geometry.x () + dx);
-	priv->geometry.setY (priv->geometry.y () + dy);
-
 	gettimeofday (&priv->lastGeometryUpdate, NULL);
 
-	priv->region.translate (dx, dy);
-	priv->inputRegion.translate (dx, dy);
-	if (!priv->frameRegion.isEmpty ())
-	    priv->frameRegion.translate (dx, dy);
-
-	priv->invisible = WINDOW_INVISIBLE (priv);
-
-	moveNotify (dx, dy, immediate);
+	/* Don't allow window movement to overwrite working geometries
+	 * last received from the server if we know there are pending
+	 * ConfigureNotify events on this window. That's a clunky workaround
+	 * and a FIXME in any case, however, until we can break the API
+	 * and remove CompWindow::move, this will need to be the case */
+
+	if (!priv->pendingConfigures.size ())
+	{
+	    priv->geometry.setX (priv->geometry.x () + dx);
+	    priv->geometry.setY (priv->geometry.y () + dy);
+	    priv->frameGeometry.setX (priv->frameGeometry.x () + dx);
+	    priv->frameGeometry.setY (priv->frameGeometry.y () + dy);
+
+	    priv->pendingPositionUpdates = true;
+
+	    priv->region.translate (dx, dy);
+	    priv->inputRegion.translate (dx, dy);
+	    if (!priv->frameRegion.isEmpty ())
+		priv->frameRegion.translate (dx, dy);
+
+	    priv->invisible = WINDOW_INVISIBLE (priv);
+
+	    moveNotify (dx, dy, immediate);
+	}
+	else
+	{
+	    XWindowChanges xwc;
+	    unsigned int   valueMask = CWX | CWY;
+	    struct timeval tv, old;
+	    compLogMessage ("core", CompLogLevelDebug, "pending configure notifies on 0x%x,"\
+			    "moving window asyncrhonously!", (unsigned int) priv->serverId);
+
+	    old = priv->lastConfigureRequest;
+	    gettimeofday (&tv, NULL);
+
+	    xwc.x = priv->serverGeometry.x () + dx;
+	    xwc.y = priv->serverGeometry.y () + dy;
+
+	    configureXWindow (valueMask, &xwc);
+
+	    priv->lastConfigureRequest = old;
+
+	    /* FIXME: This is a hack to avoid performance regressions
+	     * and must be removed in 0.9.6 */
+	    if (tv.tv_usec - priv->lastConfigureRequest.tv_usec > 30000)
+	    {
+		compLogMessage ("core", CompLogLevelWarn, "failed to receive ConfigureNotify event from request at %i (now: %i)\n",
+				priv->lastConfigureRequest.tv_usec, tv.tv_usec);
+		priv->pendingConfigures.clear ();
+	    }
+	}
     }
 }
 
 void
+PrivateWindow::addPendingConfigure (XWindowChanges &xwc, unsigned int valueMask)
+{
+    CompOption::Vector options;
+    CompOption::Value  v;
+
+    options.push_back (CompOption ("window", CompOption::TypeInt));
+    v.set ((int) id);
+    options.back ().set (v);
+    options.push_back (CompOption ("active", CompOption::TypeInt));
+    v.set ((int) 1);
+    options.back ().set (v);
+
+    gettimeofday (&lastConfigureRequest, NULL);
+
+    /* Notify other plugins that it is unsafe to change geometry or serverGeometry
+     * FIXME: That API should not be accessible to plugins, this is a hack to avoid
+     * breaking ABI */
+
+    screen->handleCompizEvent ("core", "lock_position", options);
+
+    priv->pendingConfigures.push_back (XWCValueMask (xwc, valueMask));
+}
+
+void
 CompWindow::syncPosition ()
 {
-    priv->serverGeometry.setX (priv->geometry.x ());
-    priv->serverGeometry.setY (priv->geometry.y ());
-
     gettimeofday (&priv->lastConfigureRequest, NULL);
 
-    XMoveWindow (screen->dpy (), ROOTPARENT (this),
-		 priv->serverGeometry.x () - priv->serverInput.left,
-		 priv->serverGeometry.y () - priv->serverInput.top);
+    unsigned int   valueMask = CWX | CWY;
+    XWindowChanges xwc;
 
-    if (priv->serverFrame)
+    if (priv->pendingPositionUpdates && priv->pendingConfigures.empty ())
     {
-	XMoveWindow (screen->dpy (), priv->wrapper,
-		     priv->serverInput.left, priv->serverInput.top);
-	sendConfigureNotify ();
+	if (priv->serverFrameGeometry.x () == priv->frameGeometry.x ())
+	    valueMask &= ~(CWX);
+	if (priv->serverFrameGeometry.y () == priv->frameGeometry.y ())
+	    valueMask &= ~(CWY);
+
+	/* Because CompWindow::move can update the geometry last
+	 * received from the server, we must indicate that no values
+	 * changed, because when the ConfigureNotify comes around
+	 * the values are going to be the same. That's obviously
+	 * broken behaviour and worthy of a FIXME, but requires
+	 * larger changes to the window movement system. */
+	if (valueMask)
+	{
+	    priv->addPendingConfigure (xwc, 0);
+
+	    priv->serverGeometry.setX (priv->geometry.x ());
+	    priv->serverGeometry.setY (priv->geometry.y ());
+	    priv->serverFrameGeometry.setX (priv->frameGeometry.x ());
+	    priv->serverFrameGeometry.setY (priv->frameGeometry.y ());
+
+	    xwc.x = priv->serverFrameGeometry.x ();
+	    xwc.y = priv->serverFrameGeometry.y ();
+
+	    XConfigureWindow (screen->dpy (), ROOTPARENT (this), valueMask, &xwc);
+
+	    if (priv->serverFrame)
+	    {
+		XMoveWindow (screen->dpy (), priv->wrapper,
+			     priv->serverInput.left, priv->serverInput.top);
+		sendConfigureNotify ();
+	    }
+	}
+	priv->pendingPositionUpdates = false;
     }
 }
 
@@ -2185,11 +2438,13 @@
 	vp = defaultViewport ();
 	if (screen->vp () != vp)
 	{
-	    int moveX = (screen->vp ().x () - vp.x ()) * screen->width ();
-	    int moveY = (screen->vp ().y () - vp.y ()) * screen->height ();
-
-	    move (moveX, moveY, TRUE);
-	    syncPosition ();
+	    unsigned int valueMask = CWX | CWY;
+	    XWindowChanges xwc;
+
+	    xwc.x = serverGeometry ().x () +  (screen->vp ().x () - vp.x ()) * screen->width ();
+	    xwc.y = serverGeometry ().y () +  (screen->vp ().y () - vp.y ()) * screen->height ();
+
+	    configureXWindow (valueMask, &xwc);
 	}
     }
 }
@@ -2749,6 +3004,54 @@
 PrivateWindow::reconfigureXWindow (unsigned int   valueMask,
 				   XWindowChanges *xwc)
 {
+    unsigned int frameValueMask = valueMask;
+
+    /* Immediately sync window position
+     * if plugins were updating w->geometry () directly
+     * in order to avoid a race condition */
+
+    window->syncPosition ();
+
+    /* Remove redundant bits */
+
+    if (serverGeometry.x () == xwc->x)
+	valueMask &= ~(CWX);
+
+    if (serverGeometry.y () == xwc->y)
+	valueMask &= ~(CWY);
+
+    if (serverGeometry.width () == xwc->width)
+	valueMask &= ~(CWWidth);
+
+    if (serverGeometry.height () == xwc->height)
+	valueMask &= ~(CWHeight);
+
+    if (serverGeometry.border () == xwc->border_width)
+	valueMask &= ~(CWBorderWidth);
+
+    if (window->serverPrev && ROOTPARENT (window->serverPrev) == xwc->sibling)
+    {
+	/* check if the sibling is also pending a restack,
+	 * if not, then setting this bit is useless */
+
+	bool pendingRestack = false;
+
+	foreach (XWCValueMask &xwcvm, window->serverPrev->priv->pendingConfigures)
+	{
+	    if (xwcvm.second & (CWSibling | CWStackMode))
+	    {
+		pendingRestack = true;
+		break;
+	    }
+	}
+
+	if (!pendingRestack)
+	    valueMask &= ~(CWSibling | CWStackMode);
+    }
+
+    if (valueMask & CWBorderWidth)
+	serverGeometry.setBorder (xwc->border_width);
+
     if (valueMask & CWX)
 	serverGeometry.setX (xwc->x);
 
@@ -2761,9 +3064,6 @@
     if (valueMask & CWHeight)
 	serverGeometry.setHeight (xwc->height);
 
-    if (valueMask & CWBorderWidth)
-	serverGeometry.setBorder (xwc->border_width);
-
     /* Update the server side window list on raise, lower and restack functions.
      * This function should only recieve stack_mode == Above
      * but warn incase something else does get through, to make the cause
@@ -2774,41 +3074,80 @@
 	{
 	    if (xwc->sibling)
 	    {
-		CompWindow *w = screen->findWindow (id);
-
-		screen->unhookServerWindow (w);
-		screen->insertServerWindow (w, xwc->sibling);
+		screen->unhookServerWindow (window);
+		screen->insertServerWindow (window, xwc->sibling);
 	    }
 	}
 	else
 	    compLogMessage ("core", CompLogLevelWarn, "restack_mode not Above");
     }
 
+    if (serverFrameGeometry.x () == xwc->x - serverGeometry.border () - serverInput.left)
+	frameValueMask &= ~(CWX);
+
+    if (serverFrameGeometry.y () == xwc->y - serverGeometry.border () - serverInput.top)
+	frameValueMask &= ~(CWY);
+
+   if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2
+				      + serverInput.left + serverInput.right)
+	frameValueMask &= ~(CWWidth);
+
+    if (serverFrameGeometry.height () == xwc->height + serverGeometry.border () * 2
+				      + serverInput.top + serverInput.bottom)
+	frameValueMask &= ~(CWHeight);
+
+    /* Can't set the border width of frame windows */
+    frameValueMask &= ~(CWBorderWidth);
+
+    if (frameValueMask & CWX)
+	serverFrameGeometry.setX (xwc->x - serverGeometry.border () - serverInput.left);
+
+    if (frameValueMask & CWY)
+	serverFrameGeometry.setY (xwc->y -serverGeometry.border () - serverInput.top);
+
+    if (frameValueMask & CWWidth)
+	serverFrameGeometry.setWidth (xwc->width + serverGeometry.border () * 2
+				      + serverInput.left + serverInput.right);
+
+    if (frameValueMask & CWHeight)
+	serverFrameGeometry.setHeight (xwc->height + serverGeometry.border () * 2
+				      + serverInput.top + serverInput.bottom);
+
+
     if (serverFrame)
     {
-	XWindowChanges wc = *xwc;
-
 	gettimeofday (&lastConfigureRequest, NULL);
 
-	wc.x      -= serverInput.left - serverGeometry.border ();
-	wc.y      -= serverInput.top - serverGeometry.border ();
-	wc.width  += serverInput.left + serverInput.right + serverGeometry.border ();
-	wc.height += serverInput.top + serverInput.bottom + serverGeometry.border ();
-
-	XConfigureWindow (screen->dpy (), serverFrame, valueMask, &wc);
+	if (frameValueMask)
+	{
+	    XWindowChanges wc = *xwc;
+
+	    wc.x      = serverFrameGeometry.x ();
+	    wc.y      = serverFrameGeometry.y ();
+	    wc.width  = serverFrameGeometry.width ();
+	    wc.height = serverFrameGeometry.height ();
+
+	    addPendingConfigure (wc, frameValueMask);
+
+	    XConfigureWindow (screen->dpy (), serverFrame, frameValueMask, &wc);
+	}
 	valueMask &= ~(CWSibling | CWStackMode);
 
-	xwc->x = serverInput.left;
-	xwc->y = serverInput.top;
-	XConfigureWindow (screen->dpy (), wrapper, valueMask, xwc);
+	if (valueMask)
+	{
+	    xwc->x = serverInput.left;
+	    xwc->y = serverInput.top;
+	    XConfigureWindow (screen->dpy (), wrapper, valueMask, xwc);
 
-	xwc->x = 0;
-	xwc->y = 0;
+	    xwc->x = 0;
+	    xwc->y = 0;
+	}
 
 	window->sendConfigureNotify ();
     }
 
-    XConfigureWindow (screen->dpy (), id, valueMask, xwc);
+    if (valueMask)
+	XConfigureWindow (screen->dpy (), id, valueMask, xwc);
 }
 
 bool
@@ -3574,9 +3913,30 @@
 	 * if serverPrev was recently restacked */
 	if (window->serverPrev)
 	{
-	    if (!sibling)
-	    {
-		XLowerWindow (screen->dpy (), ROOTPARENT (window));
+	    bool pendingRestacks = false;
+
+	    foreach (XWCValueMask &xwcvm, sibling->priv->pendingConfigures)
+	    {
+		if (xwcvm.second & (CWSibling | CWStackMode))
+		{
+		    pendingRestacks = true;
+		    break;
+		}
+	    }
+
+	    if (!sibling && window->serverPrev)
+	    {
+		XWindowChanges xwc;
+		unsigned int   valueMask = CWStackMode;
+
+		xwc.stack_mode = Below;
+
+		/* Below with no sibling puts the window at the bottom
+		 * of the stack */
+		XConfigureWindow (screen->dpy (), ROOTPARENT (window), valueMask, &xwc);
+
+		if (serverFrame)
+		    priv->addPendingConfigure (xwc, CWStackMode);
 
 		/* Update the list of windows last sent to the server */
 		screen->unhookServerWindow (window);
@@ -5410,6 +5770,8 @@
 
     if (tx || ty)
     {
+	unsigned int   valueMask = CWX | CWY;
+	XWindowChanges xwc;
 	int m, wx, wy;
 
 	if (!priv->managed)
@@ -5450,10 +5812,10 @@
 	if (priv->saveMask & CWY)
 	    priv->saveWc.y += wy;
 
-	move (wx, wy);
+	xwc.x = serverGeometry ().x () + wx;
+	xwc.y = serverGeometry ().y () + wy;
 
-	if (sync)
-	    syncPosition ();
+	configureXWindow (valueMask, &xwc);
     }
 }
 
@@ -5659,18 +6021,14 @@
     if (dbg)
 	dbg->overrideRedirectRestack (priv->id, aboveId);
 
-    gettimeofday (&priv->lastGeometryUpdate, NULL);
+    gettimeofday (&priv->lastConfigureRequest, NULL);
 
     priv->attrib = wa;
     priv->serverGeometry.set (priv->attrib.x, priv->attrib.y,
 			      priv->attrib.width, priv->attrib.height,
 			      priv->attrib.border_width);
-    priv->syncGeometry.set (priv->attrib.x, priv->attrib.y,
-			    priv->attrib.width, priv->attrib.height,
-			    priv->attrib.border_width);
-    priv->geometry.set (priv->attrib.x, priv->attrib.y,
-			priv->attrib.width, priv->attrib.height,
-			priv->attrib.border_width);
+    priv->serverFrameGeometry = priv->frameGeometry = priv->syncGeometry
+	    = priv->geometry = priv->serverGeometry;
 
     priv->width  = priv->attrib.width  + priv->attrib.border_width * 2;
     priv->height = priv->attrib.height + priv->attrib.border_width * 2;
@@ -5982,6 +6340,7 @@
 
     pendingUnmaps (0),
     pendingMaps (0),
+    pendingPositionUpdates (false),
 
     startupId (0),
     resName (0),
@@ -6278,7 +6637,6 @@
 	XSync (dpy, false);
 	return false;
     }
-    gettimeofday (&lastConfigureRequest, NULL);
 
     if (wa.override_redirect)
 	return false;
@@ -6309,7 +6667,7 @@
 
     priv->serverGeometry.setBorder (0);
 
-    mask = CWBorderPixel | CWColormap | CWBackPixmap;
+    mask = CWBorderPixel | CWColormap | CWBackPixmap | CWOverrideRedirect;
 
     if (wa.depth == 32)
     {
@@ -6427,6 +6785,11 @@
 		      SubstructureNotifyMask | EnterWindowMask |
 		      LeaveWindowMask;
 
+    serverFrameGeometry = serverGeometry;
+
+    XMoveResizeWindow (dpy, serverFrame, serverFrameGeometry.x (), serverFrameGeometry.y (),
+		       serverFrameGeometry.width (), serverFrameGeometry.height ());
+
     XChangeWindowAttributes (dpy, serverFrame, CWEventMask, &attr);
     XChangeWindowAttributes (dpy, wrapper, CWEventMask, &attr);
 
@@ -6447,9 +6810,6 @@
     XUngrabServer (dpy);
     XSync (dpy, false);
 
-    XMoveResizeWindow (dpy, serverFrame, wa.x, wa.y,
-		       wa.width, wa.height);
-
     window->windowNotify (CompWindowNotifyReparent);
 
     return true;
@@ -6508,6 +6868,14 @@
 	/* Wait for the reparent to finish */
 	XSync (dpy, false);
 
+	xwc.x = serverGeometry.x () - serverGeometry.border ();
+	xwc.y = serverGeometry.y () - serverGeometry.border ();
+	xwc.width = serverGeometry.width () + serverGeometry.border () * 2;
+	xwc.height = serverGeometry.height () + serverGeometry.border () * 2;
+
+	XConfigureWindow (dpy, serverFrame, CWX | CWY | CWWidth | CWHeight, &xwc);
+
+
 	xwc.stack_mode = Below;
 	xwc.sibling    = serverFrame;
 	XConfigureWindow (dpy, id, CWSibling | CWStackMode, &xwc);