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>

1 files changed, 43 insertions, 59 deletions

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)