xcb: remove code and macros related to Q_XCB_DEBUG

... early spring-cleaning, leaving one block of virtual
root debug code that was inappropriately conditioned on
Q_XCB_DEBUG; it now gets its own define.

Removed Q_XCB_CALL:
1) I don't know anyone who actually uses it.
2) Enabling this feature (via Q_XCB_DEBUG) fails to build
   (and has been like that for about 1 year).
3) There are better ways to debug X11 client message exchange
   (see xtrace for example).
4) Using Q_XCB_CALL is a very fragile approach. Grep for
   example for xcb_change_property and you will see that
   half of the calls are not wrapped with the Q_XCB_CALL
   macro.

This patch also removes the Q_XCB_NOOP macro. It's unclear
what its purpose was. There was a TODO comment in qxcbeglcontext.h
suggesting removal of this macro as well.  Its evaluation of its
parameter, even without Q_XCB_DEBUG, had no side-effects, so its
removal should be harmless.

Change-Id: I9fa48af454061d8b38f69f308131647cd18f85f4
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Alexander Volkov <a.volkov@rusbitech.ru>
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>

11 files changed, 277 insertions, 384 deletions

diff --git a/src/plugins/platforms/xcb/gl_integrations/xcb_egl/qxcbeglcontext.h b/src/plugins/platforms/xcb/gl_integrations/xcb_egl/qxcbeglcontext.h
index 48e774bbb2..5f6d9f92dd 100644
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_egl/qxcbeglcontext.h
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_egl/qxcbeglcontext.h
@@ -47,7 +47,6 @@
 
 QT_BEGIN_NAMESPACE
 
-//####todo remove the noops (looks like their where there in the initial commit)
 class QXcbEglContext : public QEGLPlatformContext
 {
 public:
@@ -56,29 +55,21 @@ public:
         : QEGLPlatformContext(glFormat, share, display, 0, nativeHandle)
         , m_connection(c)
     {
-        Q_XCB_NOOP(m_connection);
     }
 
     void swapBuffers(QPlatformSurface *surface)
     {
-        Q_XCB_NOOP(m_connection);
         QEGLPlatformContext::swapBuffers(surface);
-        Q_XCB_NOOP(m_connection);
     }
 
     bool makeCurrent(QPlatformSurface *surface)
     {
-        Q_XCB_NOOP(m_connection);
-        bool ret = QEGLPlatformContext::makeCurrent(surface);
-        Q_XCB_NOOP(m_connection);
-        return ret;
+        return QEGLPlatformContext::makeCurrent(surface);
     }
 
     void doneCurrent()
     {
-        Q_XCB_NOOP(m_connection);
         QEGLPlatformContext::doneCurrent();
-        Q_XCB_NOOP(m_connection);
     }
 
     EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface)
diff --git a/src/plugins/platforms/xcb/qxcbbackingstore.cpp b/src/plugins/platforms/xcb/qxcbbackingstore.cpp
index f095288221..e0a12f57c2 100644
--- a/src/plugins/platforms/xcb/qxcbbackingstore.cpp
+++ b/src/plugins/platforms/xcb/qxcbbackingstore.cpp
@@ -150,8 +150,6 @@ QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QI
     , m_gc_drawable(0)
     , m_xcb_pixmap(0)
 {
-    Q_XCB_NOOP(connection());
-
     const xcb_format_t *fmt = connection()->formatForDepth(depth);
     Q_ASSERT(fmt);
 
@@ -206,11 +204,11 @@ QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QI
 
     if (!hasShm()) {
         m_xcb_pixmap = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_pixmap(xcb_connection(),
-                                     m_xcb_image->depth,
-                                     m_xcb_pixmap,
-                                     screen->screen()->root,
-                                     m_xcb_image->width, m_xcb_image->height));
+        xcb_create_pixmap(xcb_connection(),
+                          m_xcb_image->depth,
+                          m_xcb_pixmap,
+                          screen->screen()->root,
+                          m_xcb_image->width, m_xcb_image->height);
     }
 }
 
@@ -234,13 +232,13 @@ bool QXcbShmImage::scroll(const QRegion &area, int dx, int dy)
         const QRect bounds(QPoint(0, 0), size());
         for (const QRect &src : area) {
             const QRect dst = src.translated(delta).intersected(bounds);
-            Q_XCB_CALL(xcb_copy_area(xcb_connection(),
-                                     m_xcb_pixmap,
-                                     m_xcb_pixmap,
-                                     m_gc,
-                                     src.x(), src.y(),
-                                     dst.x(), dst.y(),
-                                     dst.width(), dst.height()));
+            xcb_copy_area(xcb_connection(),
+                          m_xcb_pixmap,
+                          m_xcb_pixmap,
+                          m_gc,
+                          src.x(), src.y(),
+                          dst.x(), dst.y(),
+                          dst.width(), dst.height());
         }
     }
 
@@ -251,7 +249,7 @@ void QXcbShmImage::destroy()
 {
     const int segmentSize = m_xcb_image ? (m_xcb_image->stride * m_xcb_image->height) : 0;
     if (segmentSize && m_shm_info.shmaddr)
-        Q_XCB_CALL(xcb_shm_detach(xcb_connection(), m_shm_info.shmseg));
+        xcb_shm_detach(xcb_connection(), m_shm_info.shmseg);
 
     if (segmentSize) {
         if (m_shm_info.shmaddr) {
@@ -265,12 +263,12 @@ void QXcbShmImage::destroy()
     xcb_image_destroy(m_xcb_image);
 
     if (m_gc)
-        Q_XCB_CALL(xcb_free_gc(xcb_connection(), m_gc));
+        xcb_free_gc(xcb_connection(), m_gc);
     delete m_graphics_buffer;
     m_graphics_buffer = Q_NULLPTR;
 
     if (m_xcb_pixmap) {
-        Q_XCB_CALL(xcb_free_pixmap(xcb_connection(), m_xcb_pixmap));
+        xcb_free_pixmap(xcb_connection(), m_xcb_pixmap);
         m_xcb_pixmap = 0;
     }
 }
@@ -279,13 +277,13 @@ void QXcbShmImage::ensureGC(xcb_drawable_t dst)
 {
     if (m_gc_drawable != dst) {
         if (m_gc)
-            Q_XCB_CALL(xcb_free_gc(xcb_connection(), m_gc));
+            xcb_free_gc(xcb_connection(), m_gc);
 
         static const uint32_t mask = XCB_GC_GRAPHICS_EXPOSURES;
         static const uint32_t values[] = { 0 };
 
         m_gc = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_gc(xcb_connection(), m_gc, dst, mask, values));
+        xcb_create_gc(xcb_connection(), m_gc, dst, mask, values);
 
         m_gc_drawable = dst;
     }
@@ -425,10 +423,7 @@ void QXcbShmImage::setClip(const QRegion &region)
     if (region.isEmpty()) {
         static const uint32_t mask = XCB_GC_CLIP_MASK;
         static const uint32_t values[] = { XCB_NONE };
-        Q_XCB_CALL(xcb_change_gc(xcb_connection(),
-                                 m_gc,
-                                 mask,
-                                 values));
+        xcb_change_gc(xcb_connection(), m_gc, mask, values);
     } else {
         const QVector<QRect> qrects = region.rects();
         QVector<xcb_rectangle_t> xcb_rects(qrects.size());
@@ -440,18 +435,16 @@ void QXcbShmImage::setClip(const QRegion &region)
             xcb_rects[i].height = qrects[i].height();
         }
 
-        Q_XCB_CALL(xcb_set_clip_rectangles(xcb_connection(),
-                                           XCB_CLIP_ORDERING_YX_BANDED,
-                                           m_gc,
-                                           0, 0,
-                                           xcb_rects.size(), xcb_rects.constData()));
+        xcb_set_clip_rectangles(xcb_connection(),
+                                XCB_CLIP_ORDERING_YX_BANDED,
+                                m_gc,
+                                0, 0,
+                                xcb_rects.size(), xcb_rects.constData());
     }
 }
 
 void QXcbShmImage::put(xcb_drawable_t dst, const QRegion &region, const QPoint &offset)
 {
-    Q_XCB_NOOP(connection());
-
     ensureGC(dst);
     setClip(region);
 
@@ -460,33 +453,32 @@ void QXcbShmImage::put(xcb_drawable_t dst, const QRegion &region, const QPoint &
     const QRect source = bounds.translated(offset);
 
     if (hasShm()) {
-        Q_XCB_CALL(xcb_shm_put_image(xcb_connection(),
-                                     dst,
-                                     m_gc,
-                                     m_xcb_image->width,
-                                     m_xcb_image->height,
-                                     source.x(), source.y(),
-                                     source.width(), source.height(),
-                                     target.x(), target.y(),
-                                     m_xcb_image->depth,
-                                     m_xcb_image->format,
-                                     0, // send event?
-                                     m_shm_info.shmseg,
-                                     m_xcb_image->data - m_shm_info.shmaddr));
+        xcb_shm_put_image(xcb_connection(),
+                          dst,
+                          m_gc,
+                          m_xcb_image->width,
+                          m_xcb_image->height,
+                          source.x(), source.y(),
+                          source.width(), source.height(),
+                          target.x(), target.y(),
+                          m_xcb_image->depth,
+                          m_xcb_image->format,
+                          0, // send event?
+                          m_shm_info.shmseg,
+                          m_xcb_image->data - m_shm_info.shmaddr);
         m_dirtyShm |= region.translated(offset);
     } else {
         flushPixmap(region);
-        Q_XCB_CALL(xcb_copy_area(xcb_connection(),
-                                 m_xcb_pixmap,
-                                 dst,
-                                 m_gc,
-                                 source.x(), source.y(),
-                                 target.x(), target.y(),
-                                 source.width(), source.height()));
+        xcb_copy_area(xcb_connection(),
+                      m_xcb_pixmap,
+                      dst,
+                      m_gc,
+                      source.x(), source.y(),
+                      target.x(), target.y(),
+                      source.width(), source.height());
     }
 
     setClip(QRegion());
-    Q_XCB_NOOP(connection());
 }
 
 void QXcbShmImage::preparePaint(const QRegion &region)
@@ -592,8 +584,6 @@ void QXcbBackingStore::flush(QWindow *window, const QRegion &region, const QPoin
     if (bounds.isNull())
         return;
 
-    Q_XCB_NOOP(connection());
-
     QXcbWindow *platformWindow = static_cast<QXcbWindow *>(window->handle());
     if (!platformWindow) {
         qWarning("QXcbBackingStore::flush: QWindow has no platform window (QTBUG-32681)");
@@ -602,8 +592,6 @@ void QXcbBackingStore::flush(QWindow *window, const QRegion &region, const QPoin
 
     m_image->put(platformWindow->xcb_window(), clipped, offset);
 
-    Q_XCB_NOOP(connection());
-
     if (platformWindow->needsSync())
         platformWindow->updateSyncRequestCounter();
     else
@@ -617,8 +605,6 @@ void QXcbBackingStore::composeAndFlush(QWindow *window, const QRegion &region, c
 {
     QPlatformBackingStore::composeAndFlush(window, region, offset, textures, context, translucentBackground);
 
-    Q_XCB_NOOP(connection());
-
     QXcbWindow *platformWindow = static_cast<QXcbWindow *>(window->handle());
     if (platformWindow->needsSync()) {
         platformWindow->updateSyncRequestCounter();
@@ -632,7 +618,6 @@ void QXcbBackingStore::resize(const QSize &size, const QRegion &)
 {
     if (m_image && size == m_image->size())
         return;
-    Q_XCB_NOOP(connection());
 
     QXcbScreen *screen = static_cast<QXcbScreen *>(window()->screen()->handle());
     QPlatformWindow *pw = window()->handle();
@@ -649,7 +634,6 @@ void QXcbBackingStore::resize(const QSize &size, const QRegion &)
     if (win->imageNeedsRgbSwap()) {
         m_rgbImage = QImage(size, win->imageFormat());
     }
-    Q_XCB_NOOP(connection());
 }
 
 bool QXcbBackingStore::scroll(const QRegion &area, int dx, int dy)
diff --git a/src/plugins/platforms/xcb/qxcbclipboard.cpp b/src/plugins/platforms/xcb/qxcbclipboard.cpp
index a164ed0ef2..24a4c1bf22 100644
--- a/src/plugins/platforms/xcb/qxcbclipboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbclipboard.cpp
@@ -278,22 +278,22 @@ QXcbClipboard::QXcbClipboard(QXcbConnection *c)
 
 #ifndef QT_NO_DEBUG
     QByteArray ba("Qt clipboard window");
-    Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                   XCB_PROP_MODE_REPLACE,
-                                   m_owner,
-                                   atom(QXcbAtom::_NET_WM_NAME),
-                                   atom(QXcbAtom::UTF8_STRING),
-                                   8,
-                                   ba.length(),
-                                   ba.constData()));
+    xcb_change_property(xcb_connection(),
+                        XCB_PROP_MODE_REPLACE,
+                        m_owner,
+                        atom(QXcbAtom::_NET_WM_NAME),
+                        atom(QXcbAtom::UTF8_STRING),
+                        8,
+                        ba.length(),
+                        ba.constData());
 #endif
 
     if (connection()->hasXFixes()) {
         const uint32_t mask = XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
                 XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
                 XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
-        Q_XCB_CALL(xcb_xfixes_select_selection_input_checked(xcb_connection(), m_owner, XCB_ATOM_PRIMARY, mask));
-        Q_XCB_CALL(xcb_xfixes_select_selection_input_checked(xcb_connection(), m_owner, atom(QXcbAtom::CLIPBOARD), mask));
+        xcb_xfixes_select_selection_input_checked(xcb_connection(), m_owner, XCB_ATOM_PRIMARY, mask);
+        xcb_xfixes_select_selection_input_checked(xcb_connection(), m_owner, atom(QXcbAtom::CLIPBOARD), mask);
     }
 }
 
@@ -457,26 +457,26 @@ xcb_window_t QXcbClipboard::requestor() const
         QXcbClipboard *that = const_cast<QXcbClipboard *>(this);
 
         xcb_window_t window = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_window(xcb_connection(),
-                                     XCB_COPY_FROM_PARENT,            // depth -- same as root
-                                     window,                        // window id
-                                     platformScreen->screen()->root,                   // parent window id
-                                     x, y, w, h,
-                                     0,                               // border width
-                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
-                                     platformScreen->screen()->root_visual, // visual
-                                     0,                               // value mask
-                                     0));                             // value list
+        xcb_create_window(xcb_connection(),
+                          XCB_COPY_FROM_PARENT,                  // depth -- same as root
+                          window,                                // window id
+                          platformScreen->screen()->root,        // parent window id
+                          x, y, w, h,
+                          0,                                     // border width
+                          XCB_WINDOW_CLASS_INPUT_OUTPUT,         // window class
+                          platformScreen->screen()->root_visual, // visual
+                          0,                                     // value mask
+                          0);                                    // value list
 #ifndef QT_NO_DEBUG
         QByteArray ba("Qt clipboard requestor window");
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       window,
-                                       atom(QXcbAtom::_NET_WM_NAME),
-                                       atom(QXcbAtom::UTF8_STRING),
-                                       8,
-                                       ba.length(),
-                                       ba.constData()));
+        xcb_change_property(xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            window,
+                            atom(QXcbAtom::_NET_WM_NAME),
+                            atom(QXcbAtom::UTF8_STRING),
+                            8,
+                            ba.length(),
+                            ba.constData());
 #endif
 
         uint32_t mask = XCB_EVENT_MASK_PROPERTY_CHANGE;
diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index c69adab357..d7eeb5d118 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -923,18 +923,6 @@ const char *xcb_protocol_request_codes[] =
     "Unknown"
 };
 
-#ifdef Q_XCB_DEBUG
-void QXcbConnection::log(const char *file, int line, int sequence)
-{
-    QMutexLocker locker(&m_callLogMutex);
-    CallInfo info;
-    info.sequence = sequence;
-    info.file = file;
-    info.line = line;
-    m_callLog << info;
-}
-#endif
-
 void QXcbConnection::handleXcbError(xcb_generic_error_t *error)
 {
     long result = 0;
@@ -950,26 +938,6 @@ void QXcbConnection::handleXcbError(xcb_generic_error_t *error)
            int(error->sequence), int(error->resource_id),
            int(error->major_code), xcb_protocol_request_codes[clamped_major_code],
            int(error->minor_code));
-#ifdef Q_XCB_DEBUG
-    QMutexLocker locker(&m_callLogMutex);
-    int i = 0;
-    for (; i < m_callLog.size(); ++i) {
-        if (m_callLog.at(i).sequence == error->sequence) {
-            qDebug("Caused by: %s:%d", m_callLog.at(i).file.constData(), m_callLog.at(i).line);
-            break;
-        } else if (m_callLog.at(i).sequence > error->sequence) {
-            qDebug("Caused some time before: %s:%d", m_callLog.at(i).file.constData(),
-                   m_callLog.at(i).line);
-            if (i > 0)
-                qDebug("and after: %s:%d", m_callLog.at(i-1).file.constData(),
-                       m_callLog.at(i-1).line);
-            break;
-        }
-    }
-    if (i == m_callLog.size() && !m_callLog.isEmpty())
-        qDebug("Caused some time after: %s:%d", qAsConst(m_callLog).first().file.constData(),
-               qAsConst(m_callLog).first().line);
-#endif
 }
 
 static Qt::MouseButtons translateMouseButtons(int s)
@@ -1039,17 +1007,6 @@ namespace {
 
 void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
 {
-#ifdef Q_XCB_DEBUG
-    {
-        QMutexLocker locker(&m_callLogMutex);
-        int i = 0;
-        for (; i < m_callLog.size(); ++i)
-            if (m_callLog.at(i).sequence >= event->sequence)
-                break;
-        m_callLog.remove(0, i);
-    }
-#endif
-
     long result = 0;
     QAbstractEventDispatcher* dispatcher = QAbstractEventDispatcher::instance();
     bool handled = dispatcher && dispatcher->filterNativeEvent(m_nativeInterface->genericEventFilterType(), event, &result);
@@ -1362,10 +1319,10 @@ void QXcbConnection::sendConnectionEvent(QXcbAtom::Atom a, uint id)
     const xcb_window_t eventListener = xcb_generate_id(m_connection);
     xcb_screen_iterator_t it = xcb_setup_roots_iterator(m_setup);
     xcb_screen_t *screen = it.data;
-    Q_XCB_CALL(xcb_create_window(m_connection, XCB_COPY_FROM_PARENT,
-                                 eventListener, screen->root,
-                                 0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_ONLY,
-                                 screen->root_visual, 0, 0));
+    xcb_create_window(m_connection, XCB_COPY_FROM_PARENT,
+                      eventListener, screen->root,
+                      0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_ONLY,
+                      screen->root_visual, 0, 0);
 
     event.response_type = XCB_CLIENT_MESSAGE;
     event.format = 32;
@@ -1374,8 +1331,8 @@ void QXcbConnection::sendConnectionEvent(QXcbAtom::Atom a, uint id)
     event.type = atom(a);
     event.data.data32[0] = id;
 
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, eventListener, XCB_EVENT_MASK_NO_EVENT, reinterpret_cast<const char *>(&event)));
-    Q_XCB_CALL(xcb_destroy_window(m_connection, eventListener));
+    xcb_send_event(xcb_connection(), false, eventListener, XCB_EVENT_MASK_NO_EVENT, reinterpret_cast<const char *>(&event));
+    xcb_destroy_window(m_connection, eventListener);
     xcb_flush(xcb_connection());
 }
 
@@ -1443,16 +1400,16 @@ xcb_window_t QXcbConnection::getQtSelectionOwner()
         int16_t x = 0, y = 0;
         uint16_t w = 3, h = 3;
         m_qtSelectionOwner = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_window(xcb_connection(),
-                                     XCB_COPY_FROM_PARENT,               // depth -- same as root
-                                     m_qtSelectionOwner,                 // window id
-                                     xcbScreen->root,                    // parent window id
-                                     x, y, w, h,
-                                     0,                                  // border width
-                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,      // window class
-                                     xcbScreen->root_visual,             // visual
-                                     0,                                  // value mask
-                                     0));                                // value list
+        xcb_create_window(xcb_connection(),
+                          XCB_COPY_FROM_PARENT,               // depth -- same as root
+                          m_qtSelectionOwner,                 // window id
+                          xcbScreen->root,                    // parent window id
+                          x, y, w, h,
+                          0,                                  // border width
+                          XCB_WINDOW_CLASS_INPUT_OUTPUT,      // window class
+                          xcbScreen->root_visual,             // visual
+                          0,                                  // value mask
+                          0);                                 // value list
     }
     return m_qtSelectionOwner;
 }
@@ -1468,47 +1425,47 @@ xcb_window_t QXcbConnection::clientLeader()
     if (m_clientLeader == 0) {
         m_clientLeader = xcb_generate_id(xcb_connection());
         QXcbScreen *screen = primaryScreen();
-        Q_XCB_CALL(xcb_create_window(xcb_connection(),
-                                     XCB_COPY_FROM_PARENT,
-                                     m_clientLeader,
-                                     screen->root(),
-                                     0, 0, 1, 1,
-                                     0,
-                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
-                                     screen->screen()->root_visual,
-                                     0, 0));
+        xcb_create_window(xcb_connection(),
+                          XCB_COPY_FROM_PARENT,
+                          m_clientLeader,
+                          screen->root(),
+                          0, 0, 1, 1,
+                          0,
+                          XCB_WINDOW_CLASS_INPUT_OUTPUT,
+                          screen->screen()->root_visual,
+                          0, 0);
 #ifndef QT_NO_DEBUG
         QByteArray ba("Qt client leader window");
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       m_clientLeader,
-                                       atom(QXcbAtom::_NET_WM_NAME),
-                                       atom(QXcbAtom::UTF8_STRING),
-                                       8,
-                                       ba.length(),
-                                       ba.constData()));
+        xcb_change_property(xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            m_clientLeader,
+                            atom(QXcbAtom::_NET_WM_NAME),
+                            atom(QXcbAtom::UTF8_STRING),
+                            8,
+                            ba.length(),
+                            ba.constData());
 #endif
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       m_clientLeader,
-                                       atom(QXcbAtom::WM_CLIENT_LEADER),
-                                       XCB_ATOM_WINDOW,
-                                       32,
-                                       1,
-                                       &m_clientLeader));
+        xcb_change_property(xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            m_clientLeader,
+                            atom(QXcbAtom::WM_CLIENT_LEADER),
+                            XCB_ATOM_WINDOW,
+                            32,
+                            1,
+                            &m_clientLeader);
 
 #if !defined(QT_NO_SESSIONMANAGER) && defined(XCB_USE_SM)
         // If we are session managed, inform the window manager about it
         QByteArray session = qGuiApp->sessionId().toLatin1();
         if (!session.isEmpty()) {
-            Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                           XCB_PROP_MODE_REPLACE,
-                                           m_clientLeader,
-                                           atom(QXcbAtom::SM_CLIENT_ID),
-                                           XCB_ATOM_STRING,
-                                           8,
-                                           session.length(),
-                                           session.constData()));
+            xcb_change_property(xcb_connection(),
+                                XCB_PROP_MODE_REPLACE,
+                                m_clientLeader,
+                                atom(QXcbAtom::SM_CLIENT_ID),
+                                XCB_ATOM_STRING,
+                                8,
+                                session.length(),
+                                session.constData());
         }
 #endif
     }
@@ -1994,7 +1951,7 @@ const xcb_format_t *QXcbConnection::formatForDepth(uint8_t depth) const
 void QXcbConnection::sync()
 {
     // from xcb_aux_sync
-    xcb_get_input_focus_cookie_t cookie = Q_XCB_CALL(xcb_get_input_focus(xcb_connection()));
+    xcb_get_input_focus_cookie_t cookie = xcb_get_input_focus(xcb_connection());
     free(xcb_get_input_focus_reply(xcb_connection(), cookie, 0));
 }
 
diff --git a/src/plugins/platforms/xcb/qxcbconnection.h b/src/plugins/platforms/xcb/qxcbconnection.h
index c298c08322..fa4fd68686 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@@ -83,8 +83,6 @@ struct XInput2TouchDeviceData;
 
 struct xcb_randr_get_output_info_reply_t;
 
-//#define Q_XCB_DEBUG
-
 QT_BEGIN_NAMESPACE
 
 Q_DECLARE_LOGGING_CATEGORY(lcQpaXInput)
@@ -649,23 +647,6 @@ private:
     } m_startSystemResizeInfo;
 #endif
 #endif
-#ifdef Q_XCB_DEBUG
-    struct CallInfo {
-        int sequence;
-        QByteArray file;
-        int line;
-    };
-    QVector<CallInfo> m_callLog;
-    QMutex m_callLogMutex;
-    void log(const char *file, int line, int sequence);
-    template <typename cookie_t>
-    friend cookie_t q_xcb_call_template(const cookie_t &cookie, QXcbConnection *connection,
-                                        const char *file, int line);
-    template <typename reply_t>
-    friend reply_t *q_xcb_call_template(reply_t *reply, QXcbConnection *connection,
-                                        const char *file, int line);
-#endif
-
     WindowMapper m_mapper;
 
     QVector<PeekFunc> m_peekFuncs;
@@ -747,30 +728,6 @@ private:
         std::free \
     )
 
-#ifdef Q_XCB_DEBUG
-template <typename cookie_t>
-cookie_t q_xcb_call_template(const cookie_t &cookie, QXcbConnection *connection, const char *file,
-                             int line)
-{
-    connection->log(file, line, cookie.sequence);
-    return cookie;
-}
-
-template <typename reply_t>
-reply_t *q_xcb_call_template(reply_t *reply, QXcbConnection *connection, const char *file, int line)
-{
-    connection->log(file, line, reply->sequence);
-    return reply;
-}
-#define Q_XCB_CALL(x) q_xcb_call_template(x, connection(), __FILE__, __LINE__)
-#define Q_XCB_CALL2(x, connection) q_xcb_call_template(x, connection, __FILE__, __LINE__)
-#define Q_XCB_NOOP(c) q_xcb_call_template(xcb_no_operation(c->xcb_connection()), c, __FILE__, __LINE__);
-#else
-#define Q_XCB_CALL(x) x
-#define Q_XCB_CALL2(x, connection) x
-#define Q_XCB_NOOP(c) (void)c;
-#endif
-
 QT_END_NAMESPACE
 
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp
index 4dc132c667..64bbc67101 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.cpp
+++ b/src/plugins/platforms/xcb/qxcbdrag.cpp
@@ -780,8 +780,8 @@ void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message
         handle_xdnd_status(&response);
     else
 #endif
-        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, current_proxy_target,
-                                  XCB_EVENT_MASK_NO_EVENT, (const char *)&response));
+    xcb_send_event(xcb_connection(), false, current_proxy_target,
+                   XCB_EVENT_MASK_NO_EVENT, (const char *)&response);
 }
 
 namespace
@@ -985,8 +985,8 @@ void QXcbDrag::handleDrop(QPlatformWindow *, const xcb_client_message_event_t *e
     finished.data.data32[0] = currentWindow ? xcb_window(currentWindow.data()) : XCB_NONE;
     finished.data.data32[1] = response.isAccepted(); // flags
     finished.data.data32[2] = toXdndAction(response.acceptedAction());
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, current_proxy_target,
-                              XCB_EVENT_MASK_NO_EVENT, (char *)&finished));
+    xcb_send_event(xcb_connection(), false, current_proxy_target,
+                   XCB_EVENT_MASK_NO_EVENT, (char *)&finished);
 
     xdnd_dragsource = 0;
     currentWindow.clear();
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.cpp b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
index e71e77695c..275b8bdc84 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
@@ -1427,8 +1427,6 @@ private:
 void QXcbKeyboard::handleKeyEvent(xcb_window_t sourceWindow, QEvent::Type type, xcb_keycode_t code,
                                   quint16 state, xcb_timestamp_t time)
 {
-    Q_XCB_NOOP(connection());
-
     if (!m_config)
         return;
 
diff --git a/src/plugins/platforms/xcb/qxcbscreen.cpp b/src/plugins/platforms/xcb/qxcbscreen.cpp
index de73566606..0fc872cf7e 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.cpp
+++ b/src/plugins/platforms/xcb/qxcbscreen.cpp
@@ -184,7 +184,7 @@ void QXcbVirtualDesktop::subscribeToXFixesSelectionNotify()
         const uint32_t mask = XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
                               XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
                               XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
-        Q_XCB_CALL(xcb_xfixes_select_selection_input_checked(xcb_connection(), connection()->getQtSelectionOwner(), m_net_wm_cm_atom, mask));
+        xcb_xfixes_select_selection_input_checked(xcb_connection(), connection()->getQtSelectionOwner(), m_net_wm_cm_atom, mask);
     }
 }
 
diff --git a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
index 3939fc9005..c98879c7df 100644
--- a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
+++ b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
@@ -116,7 +116,7 @@ xcb_window_t QXcbSystemTrayTracker::trayWindow()
             m_connection->addWindowEventListener(m_trayWindow, this);
             const quint32 mask = XCB_CW_EVENT_MASK;
             const quint32 value = XCB_EVENT_MASK_STRUCTURE_NOTIFY;
-            Q_XCB_CALL2(xcb_change_window_attributes(m_connection->xcb_connection(), m_trayWindow, mask, &value), m_connection);
+            xcb_change_window_attributes(m_connection->xcb_connection(), m_trayWindow, mask, &value);
         }
     }
     return m_trayWindow;
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index abd41bb942..52e74c2364 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -435,11 +435,11 @@ void QXcbWindow::create()
 
     if ((window()->supportsOpenGL() && haveOpenGL) || m_format.hasAlpha()) {
         m_cmap = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_colormap(xcb_connection(),
-                                       XCB_COLORMAP_ALLOC_NONE,
-                                       m_cmap,
-                                       xcb_parent_id,
-                                       m_visualId));
+        xcb_create_colormap(xcb_connection(),
+                            XCB_COLORMAP_ALLOC_NONE,
+                            m_cmap,
+                            xcb_parent_id,
+                            m_visualId);
 
         mask |= XCB_CW_COLORMAP;
     }
@@ -455,23 +455,23 @@ void QXcbWindow::create()
     };
 
     m_window = xcb_generate_id(xcb_connection());
-    Q_XCB_CALL(xcb_create_window(xcb_connection(),
-                                 m_depth,
-                                 m_window,                        // window id
-                                 xcb_parent_id,                   // parent window id
-                                 rect.x(),
-                                 rect.y(),
-                                 rect.width(),
-                                 rect.height(),
-                                 0,                               // border width
-                                 XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
-                                 m_visualId,                      // visual
-                                 mask,
-                                 values));
+    xcb_create_window(xcb_connection(),
+                      m_depth,
+                      m_window,                        // window id
+                      xcb_parent_id,                   // parent window id
+                      rect.x(),
+                      rect.y(),
+                      rect.width(),
+                      rect.height(),
+                      0,                               // border width
+                      XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
+                      m_visualId,                      // visual
+                      mask,
+                      values);
 
     connection()->addWindowEventListener(m_window, this);
 
-    Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));
+    xcb_change_window_attributes(xcb_connection(), m_window, mask, values);
 
     propagateSizeHints();
 
@@ -489,43 +489,43 @@ void QXcbWindow::create()
     if (window()->flags() & Qt::WindowContextHelpButtonHint)
         properties[propertyCount++] = atom(QXcbAtom::_NET_WM_CONTEXT_HELP);
 
-    Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                   XCB_PROP_MODE_REPLACE,
-                                   m_window,
-                                   atom(QXcbAtom::WM_PROTOCOLS),
-                                   XCB_ATOM_ATOM,
-                                   32,
-                                   propertyCount,
-                                   properties));
+    xcb_change_property(xcb_connection(),
+                        XCB_PROP_MODE_REPLACE,
+                        m_window,
+                        atom(QXcbAtom::WM_PROTOCOLS),
+                        XCB_ATOM_ATOM,
+                        32,
+                        propertyCount,
+                        properties);
     m_syncValue.hi = 0;
     m_syncValue.lo = 0;
 
     const QByteArray wmClass = QXcbIntegration::instance()->wmClass();
     if (!wmClass.isEmpty()) {
-        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE,
-                                       m_window, atom(QXcbAtom::WM_CLASS),
-                                       XCB_ATOM_STRING, 8, wmClass.size(), wmClass.constData()));
+        xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE,
+                            m_window, atom(QXcbAtom::WM_CLASS),
+                            XCB_ATOM_STRING, 8, wmClass.size(), wmClass.constData());
     }
 
     if (m_usingSyncProtocol) {
         m_syncCounter = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_sync_create_counter(xcb_connection(), m_syncCounter, m_syncValue));
+        xcb_sync_create_counter(xcb_connection(), m_syncCounter, m_syncValue);
 
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       m_window,
-                                       atom(QXcbAtom::_NET_WM_SYNC_REQUEST_COUNTER),
-                                       XCB_ATOM_CARDINAL,
-                                       32,
-                                       1,
-                                       &m_syncCounter));
+        xcb_change_property(xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            m_window,
+                            atom(QXcbAtom::_NET_WM_SYNC_REQUEST_COUNTER),
+                            XCB_ATOM_CARDINAL,
+                            32,
+                            1,
+                            &m_syncCounter);
     }
 
     // set the PID to let the WM kill the application if unresponsive
     quint32 pid = getpid();
-    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                   atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
-                                   1, &pid));
+    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                        atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
+                        1, &pid);
 
     xcb_wm_hints_t hints;
     memset(&hints, 0, sizeof(hints));
@@ -536,16 +536,16 @@ void QXcbWindow::create()
     xcb_set_wm_hints(xcb_connection(), m_window, &hints);
 
     xcb_window_t leader = connection()->clientLeader();
-    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                   atom(QXcbAtom::WM_CLIENT_LEADER), XCB_ATOM_WINDOW, 32,
-                                   1, &leader));
+    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                        atom(QXcbAtom::WM_CLIENT_LEADER), XCB_ATOM_WINDOW, 32,
+                        1, &leader);
 
     /* Add XEMBED info; this operation doesn't initiate the embedding. */
     quint32 data[] = { XEMBED_VERSION, XEMBED_MAPPED };
-    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                   atom(QXcbAtom::_XEMBED_INFO),
-                                   atom(QXcbAtom::_XEMBED_INFO),
-                                   32, 2, (void *)data));
+    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                        atom(QXcbAtom::_XEMBED_INFO),
+                        atom(QXcbAtom::_XEMBED_INFO),
+                        32, 2, (void *)data);
 
 
 #if defined(XCB_USE_XINPUT2)
@@ -604,7 +604,7 @@ void QXcbWindow::destroy()
         connection()->setMouseGrabber(Q_NULLPTR);
 
     if (m_syncCounter && m_usingSyncProtocol)
-        Q_XCB_CALL(xcb_sync_destroy_counter(xcb_connection(), m_syncCounter));
+        xcb_sync_destroy_counter(xcb_connection(), m_syncCounter);
     if (m_window) {
         if (m_netWmUserTimeWindow) {
             xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW));
@@ -615,7 +615,7 @@ void QXcbWindow::destroy()
             m_netWmUserTimeWindow = XCB_NONE;
         }
         connection()->removeWindowEventListener(m_window);
-        Q_XCB_CALL(xcb_destroy_window(xcb_connection(), m_window));
+        xcb_destroy_window(xcb_connection(), m_window);
         m_window = 0;
     }
     if (m_cmap) {
@@ -650,7 +650,7 @@ void QXcbWindow::setGeometry(const QRect &rect)
             qBound<qint32>(1,           wmGeometry.width(),  XCOORD_MAX),
             qBound<qint32>(1,           wmGeometry.height(), XCOORD_MAX),
         };
-        Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values)));
+        xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values));
     } else {
         const quint32 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
         const qint32 values[] = {
@@ -659,7 +659,7 @@ void QXcbWindow::setGeometry(const QRect &rect)
             qBound<qint32>(1,           wmGeometry.width(),  XCOORD_MAX),
             qBound<qint32>(1,           wmGeometry.height(), XCOORD_MAX),
         };
-        Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values)));
+        xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values));
     }
 
     xcb_flush(xcb_connection());
@@ -788,13 +788,13 @@ void QXcbWindow::show()
             if (!transientXcbParent)
                 transientXcbParent = connection()->clientLeader();
             if (transientXcbParent) { // ICCCM 4.1.2.6
-                Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                               XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
-                                               1, &transientXcbParent));
+                xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                                    XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
+                                    1, &transientXcbParent);
             }
         }
         if (!transientXcbParent)
-            Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, XCB_ATOM_WM_TRANSIENT_FOR));
+            xcb_delete_property(xcb_connection(), m_window, XCB_ATOM_WM_TRANSIENT_FOR);
 
         // update _MOTIF_WM_HINTS
         updateMotifWmHintsBeforeMap();
@@ -811,7 +811,7 @@ void QXcbWindow::show()
     if (window()->objectName() == QLatin1String("QSystemTrayIconSysWindow"))
         return; // defer showing until XEMBED_EMBEDDED_NOTIFY
 
-    Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
+    xcb_map_window(xcb_connection(), m_window);
 
     if (QGuiApplication::modalWindow() == window())
         requestActivateWindow();
@@ -823,7 +823,7 @@ void QXcbWindow::show()
 
 void QXcbWindow::hide()
 {
-    Q_XCB_CALL(xcb_unmap_window(xcb_connection(), m_window));
+    xcb_unmap_window(xcb_connection(), m_window);
 
     // send synthetic UnmapNotify event according to icccm 4.1.4
     xcb_unmap_notify_event_t event;
@@ -831,8 +831,8 @@ void QXcbWindow::hide()
     event.event = xcbScreen()->root();
     event.window = m_window;
     event.from_configure = false;
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, xcbScreen()->root(),
-                              XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+    xcb_send_event(xcb_connection(), false, xcbScreen()->root(),
+                   XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event);
 
     xcb_flush(xcb_connection());
 
@@ -1003,16 +1003,16 @@ static QtMotifWmHints getMotifWmHints(QXcbConnection *c, xcb_window_t window)
 static void setMotifWmHints(QXcbConnection *c, xcb_window_t window, const QtMotifWmHints &hints)
 {
     if (hints.flags != 0l) {
-        Q_XCB_CALL2(xcb_change_property(c->xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       window,
-                                       c->atom(QXcbAtom::_MOTIF_WM_HINTS),
-                                       c->atom(QXcbAtom::_MOTIF_WM_HINTS),
-                                       32,
-                                       5,
-                                       &hints), c);
+        xcb_change_property(c->xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            window,
+                            c->atom(QXcbAtom::_MOTIF_WM_HINTS),
+                            c->atom(QXcbAtom::_MOTIF_WM_HINTS),
+                            32,
+                            5,
+                            &hints);
     } else {
-        Q_XCB_CALL2(xcb_delete_property(c->xcb_connection(), window, c->atom(QXcbAtom::_MOTIF_WM_HINTS)), c);
+        xcb_delete_property(c->xcb_connection(), window, c->atom(QXcbAtom::_MOTIF_WM_HINTS));
     }
 }
 
@@ -1083,11 +1083,11 @@ void QXcbWindow::setNetWmStates(NetWmStates states)
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION));
 
     if (atoms.isEmpty()) {
-        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_STATE)));
+        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_STATE));
     } else {
-        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                       atom(QXcbAtom::_NET_WM_STATE), XCB_ATOM_ATOM, 32,
-                                       atoms.count(), atoms.constData()));
+        xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                            atom(QXcbAtom::_NET_WM_STATE), XCB_ATOM_ATOM, 32,
+                            atoms.count(), atoms.constData());
     }
     xcb_flush(xcb_connection());
 }
@@ -1210,7 +1210,9 @@ void QXcbWindow::changeNetWmState(bool set, xcb_atom_t one, xcb_atom_t two)
     event.data.data32[3] = 0;
     event.data.data32[4] = 0;
 
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), 0, xcbScreen()->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+    xcb_send_event(xcb_connection(), 0, xcbScreen()->root(),
+                   XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
+                   (const char *)&event);
 }
 
 void QXcbWindow::setWindowState(Qt::WindowState state)
@@ -1221,7 +1223,7 @@ void QXcbWindow::setWindowState(Qt::WindowState state)
     // unset old state
     switch (m_windowState) {
     case Qt::WindowMinimized:
-        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
+        xcb_map_window(xcb_connection(), m_window);
         break;
     case Qt::WindowMaximized:
         changeNetWmState(false,
@@ -1252,7 +1254,9 @@ void QXcbWindow::setWindowState(Qt::WindowState state)
             event.data.data32[3] = 0;
             event.data.data32[4] = 0;
 
-            Q_XCB_CALL(xcb_send_event(xcb_connection(), 0, xcbScreen()->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+            xcb_send_event(xcb_connection(), 0, xcbScreen()->root(),
+                           XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
+                           (const char *)&event);
         }
         break;
     case Qt::WindowMaximized:
@@ -1378,30 +1382,30 @@ void QXcbWindow::updateNetWmUserTime(xcb_timestamp_t timestamp)
     if (m_netWmUserTimeWindow || isSupportedByWM) {
         if (!m_netWmUserTimeWindow) {
             m_netWmUserTimeWindow = xcb_generate_id(xcb_connection());
-            Q_XCB_CALL(xcb_create_window(xcb_connection(),
-                                         XCB_COPY_FROM_PARENT,            // depth -- same as root
-                                         m_netWmUserTimeWindow,                        // window id
-                                         m_window,                   // parent window id
-                                         -1, -1, 1, 1,
-                                         0,                               // border width
-                                         XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
-                                         m_visualId,                      // visual
-                                         0,                               // value mask
-                                         0));                             // value list
+            xcb_create_window(xcb_connection(),
+                              XCB_COPY_FROM_PARENT,            // depth -- same as root
+                              m_netWmUserTimeWindow,           // window id
+                              m_window,                        // parent window id
+                              -1, -1, 1, 1,
+                              0,                               // border width
+                              XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
+                              m_visualId,                      // visual
+                              0,                               // value mask
+                              0);                              // value list
             wid = m_netWmUserTimeWindow;
             xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::_NET_WM_USER_TIME_WINDOW),
                                 XCB_ATOM_WINDOW, 32, 1, &m_netWmUserTimeWindow);
             xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_USER_TIME));
 #ifndef QT_NO_DEBUG
             QByteArray ba("Qt NET_WM user time window");
-            Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                           XCB_PROP_MODE_REPLACE,
-                                           m_netWmUserTimeWindow,
-                                           atom(QXcbAtom::_NET_WM_NAME),
-                                           atom(QXcbAtom::UTF8_STRING),
-                                           8,
-                                           ba.length(),
-                                           ba.constData()));
+            xcb_change_property(xcb_connection(),
+                                XCB_PROP_MODE_REPLACE,
+                                m_netWmUserTimeWindow,
+                                atom(QXcbAtom::_NET_WM_NAME),
+                                atom(QXcbAtom::UTF8_STRING),
+                                8,
+                                ba.length(),
+                                ba.constData());
 #endif
         } else if (!isSupportedByWM) {
             // WM no longer supports it, then we should remove the
@@ -1475,21 +1479,21 @@ void QXcbWindow::setParent(const QPlatformWindow *parent)
         xcb_parent_id = xcbScreen()->root();
         m_embedded = false;
     }
-    Q_XCB_CALL(xcb_reparent_window(xcb_connection(), xcb_window(), xcb_parent_id, topLeft.x(), topLeft.y()));
+    xcb_reparent_window(xcb_connection(), xcb_window(), xcb_parent_id, topLeft.x(), topLeft.y());
 }
 
 void QXcbWindow::setWindowTitle(const QString &title)
 {
     const QString fullTitle = formatWindowTitle(title, QString::fromUtf8(" \xe2\x80\x94 ")); // unicode character U+2014, EM DASH
     const QByteArray ba = fullTitle.toUtf8();
-    Q_XCB_CALL(xcb_change_property(xcb_connection(),
+    xcb_change_property(xcb_connection(),
                                    XCB_PROP_MODE_REPLACE,
                                    m_window,
                                    atom(QXcbAtom::_NET_WM_NAME),
                                    atom(QXcbAtom::UTF8_STRING),
                                    8,
                                    ba.length(),
-                                   ba.constData()));
+                                   ba.constData());
 
 #ifdef XCB_USE_XLIB
     XTextProperty *text = qstringToXTP(DISPLAY_FROM_XCB(this), title);
@@ -1502,14 +1506,14 @@ void QXcbWindow::setWindowTitle(const QString &title)
 void QXcbWindow::setWindowIconText(const QString &title)
 {
     const QByteArray ba = title.toUtf8();
-    Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                   XCB_PROP_MODE_REPLACE,
-                                   m_window,
-                                   atom(QXcbAtom::_NET_WM_ICON_NAME),
-                                   atom(QXcbAtom::UTF8_STRING),
-                                   8,
-                                   ba.length(),
-                                   ba.constData()));
+    xcb_change_property(xcb_connection(),
+                        XCB_PROP_MODE_REPLACE,
+                        m_window,
+                        atom(QXcbAtom::_NET_WM_ICON_NAME),
+                        atom(QXcbAtom::UTF8_STRING),
+                        8,
+                        ba.length(),
+                        ba.constData());
 }
 
 void QXcbWindow::setWindowIcon(const QIcon &icon)
@@ -1539,18 +1543,18 @@ void QXcbWindow::setWindowIcon(const QIcon &icon)
     }
 
     if (!icon_data.isEmpty()) {
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       m_window,
-                                       atom(QXcbAtom::_NET_WM_ICON),
-                                       atom(QXcbAtom::CARDINAL),
-                                       32,
-                                       icon_data.size(),
-                                       (unsigned char *) icon_data.data()));
+        xcb_change_property(xcb_connection(),
+                            XCB_PROP_MODE_REPLACE,
+                            m_window,
+                            atom(QXcbAtom::_NET_WM_ICON),
+                            atom(QXcbAtom::CARDINAL),
+                            32,
+                            icon_data.size(),
+                            (unsigned char *) icon_data.data());
     } else {
-        Q_XCB_CALL(xcb_delete_property(xcb_connection(),
-                                       m_window,
-                                       atom(QXcbAtom::_NET_WM_ICON)));
+        xcb_delete_property(xcb_connection(),
+                            m_window,
+                            atom(QXcbAtom::_NET_WM_ICON));
     }
 }
 
@@ -1558,14 +1562,14 @@ void QXcbWindow::raise()
 {
     const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
     const quint32 values[] = { XCB_STACK_MODE_ABOVE };
-    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
+    xcb_configure_window(xcb_connection(), m_window, mask, values);
 }
 
 void QXcbWindow::lower()
 {
     const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
     const quint32 values[] = { XCB_STACK_MODE_BELOW };
-    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
+    xcb_configure_window(xcb_connection(), m_window, mask, values);
 }
 
 // Adapt the geometry to match the WM expection with regards
@@ -1659,9 +1663,11 @@ void QXcbWindow::requestActivateWindow()
         event.data.data32[3] = 0;
         event.data.data32[4] = 0;
 
-        Q_XCB_CALL(xcb_send_event(xcb_connection(), 0, xcbScreen()->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+        xcb_send_event(xcb_connection(), 0, xcbScreen()->root(),
+                       XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
+                       (const char *)&event);
     } else {
-        Q_XCB_CALL(xcb_set_input_focus(xcb_connection(), XCB_INPUT_FOCUS_PARENT, m_window, connection()->time()));
+        xcb_set_input_focus(xcb_connection(), XCB_INPUT_FOCUS_PARENT, m_window, connection()->time());
     }
 
     connection()->sync();
@@ -1845,20 +1851,20 @@ void QXcbWindow::setWmWindowType(QXcbWindowFunctions::WmWindowTypes types, Qt::W
         atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL));
 
     if (atoms.isEmpty()) {
-        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE)));
+        xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE));
     } else {
-        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                       atom(QXcbAtom::_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
-                                       atoms.count(), atoms.constData()));
+        xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                            atom(QXcbAtom::_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
+                            atoms.count(), atoms.constData());
     }
     xcb_flush(xcb_connection());
 }
 
 void QXcbWindow::setWmWindowRole(const QByteArray &role)
 {
-    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                   atom(QXcbAtom::WM_WINDOW_ROLE), XCB_ATOM_STRING, 8,
-                                   role.size(), role.constData()));
+    xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                        atom(QXcbAtom::WM_WINDOW_ROLE), XCB_ATOM_STRING, 8,
+                        role.size(), role.constData());
 }
 
 void QXcbWindow::setParentRelativeBackPixmapStatic(QWindow *window)
@@ -1871,7 +1877,7 @@ void QXcbWindow::setParentRelativeBackPixmap()
 {
     const quint32 mask = XCB_CW_BACK_PIXMAP;
     const quint32 values[] = { XCB_BACK_PIXMAP_PARENT_RELATIVE };
-    Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));
+    xcb_change_window_attributes(xcb_connection(), m_window, mask, values);
 }
 
 bool QXcbWindow::requestSystemTrayWindowDockStatic(const QWindow *window)
@@ -2547,7 +2553,7 @@ void QXcbWindow::updateSyncRequestCounter()
         return;
     }
     if (m_usingSyncProtocol && (m_syncValue.lo != 0 || m_syncValue.hi != 0)) {
-        Q_XCB_CALL(xcb_sync_set_counter(xcb_connection(), m_syncCounter, m_syncValue));
+        xcb_sync_set_counter(xcb_connection(), m_syncCounter, m_syncValue);
         xcb_flush(xcb_connection());
 
         m_syncValue.lo = 0;
@@ -2714,8 +2720,7 @@ void QXcbWindow::sendXEmbedMessage(xcb_window_t window, quint32 message,
     event.data.data32[2] = detail;
     event.data.data32[3] = data1;
     event.data.data32[4] = data2;
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, window,
-                              XCB_EVENT_MASK_NO_EVENT, (const char *)&event));
+    xcb_send_event(xcb_connection(), false, window, XCB_EVENT_MASK_NO_EVENT, (const char *)&event);
 }
 
 static bool activeWindowChangeQueued(const QWindow *window)
@@ -2737,12 +2742,12 @@ void QXcbWindow::handleXEmbedMessage(const xcb_client_message_event_t *event)
     case XEMBED_WINDOW_DEACTIVATE:
         break;
     case XEMBED_EMBEDDED_NOTIFY:
-        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
+        xcb_map_window(xcb_connection(), m_window);
         xcbScreen()->windowShown(this);
         // Without Qt::WA_TranslucentBackground, we use a ParentRelative BackPixmap.
         // Clear the whole tray icon window to its background color as early as possible
         // so that we can get a clean result from grabWindow() later.
-        Q_XCB_CALL(xcb_clear_area(xcb_connection(), false, m_window, 0, 0, geometry().width(), geometry().height()));
+        xcb_clear_area(xcb_connection(), false, m_window, 0, 0, geometry().width(), geometry().height());
         xcb_flush(xcb_connection());
         break;
     case XEMBED_FOCUS_IN:
@@ -2789,14 +2794,14 @@ void QXcbWindow::setOpacity(qreal level)
 
     quint32 value = qRound64(qBound(qreal(0), level, qreal(1)) * 0xffffffff);
 
-    Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                   XCB_PROP_MODE_REPLACE,
-                                   m_window,
-                                   atom(QXcbAtom::_NET_WM_WINDOW_OPACITY),
-                                   XCB_ATOM_CARDINAL,
-                                   32,
-                                   1,
-                                   (uchar *)&value));
+    xcb_change_property(xcb_connection(),
+                        XCB_PROP_MODE_REPLACE,
+                        m_window,
+                        atom(QXcbAtom::_NET_WM_WINDOW_OPACITY),
+                        XCB_ATOM_CARDINAL,
+                        32,
+                        1,
+                        (uchar *)&value);
 }
 
 void QXcbWindow::setMask(const QRegion &region)
diff --git a/src/plugins/platforms/xcb/qxcbwmsupport.cpp b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
index 05cf4c6c1a..2619892b19 100644
--- a/src/plugins/platforms/xcb/qxcbwmsupport.cpp
+++ b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
@@ -117,7 +117,8 @@ void QXcbWMSupport::updateVirtualRoots()
 
     } while (remaining > 0);
 
-#ifdef Q_XCB_DEBUG
+//#define VIRTUAL_ROOTS_DEBUG
+#ifdef VIRTUAL_ROOTS_DEBUG
     qDebug("======== updateVirtualRoots");
     for (int i = 0; i < net_virtual_roots.size(); ++i)
         qDebug() << connection()->atomName(net_virtual_roots.at(i));