xcb: Wrap xcb callings in macros

... to improve readability and reliability.

This change introduces macros Q_XCB_REPLY and Q_XCB_REPLY_UNCHECKED
that allow to replace couples of xcb cookie/reply callings by
a single "calling" of a macro. The macros wrap the reply in
std::unique_ptr thus preventing the need to free it manually.

The following C++11 features are used:
  - variadic macros
  - std::unique_ptr
  - auto type deduction

Change-Id: Icf9b93353404a39bf5f4a4562b9234db18cac696
Reviewed-by: Gatis Paeglis <gatis.paeglis@qt.io>

1 files changed, 35 insertions, 75 deletions

diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp
index 58fb1f3918..4dc132c667 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.cpp
+++ b/src/plugins/platforms/xcb/qxcbdrag.cpp
@@ -94,32 +94,27 @@ static xcb_window_t xdndProxy(QXcbConnection *c, xcb_window_t w)
 {
     xcb_window_t proxy = XCB_NONE;
 
-    xcb_get_property_cookie_t cookie = Q_XCB_CALL2(xcb_get_property(c->xcb_connection(), false, w, c->atom(QXcbAtom::XdndProxy),
-                                                        XCB_ATOM_WINDOW, 0, 1), c);
-    xcb_get_property_reply_t *reply = xcb_get_property_reply(c->xcb_connection(), cookie, 0);
+    auto reply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(),
+                             false, w, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1);
 
     if (reply && reply->type == XCB_ATOM_WINDOW)
-        proxy = *((xcb_window_t *)xcb_get_property_value(reply));
-    free(reply);
+        proxy = *((xcb_window_t *)xcb_get_property_value(reply.get()));
 
     if (proxy == XCB_NONE)
         return proxy;
 
     // exists and is real?
-    cookie = Q_XCB_CALL2(xcb_get_property(c->xcb_connection(), false, proxy, c->atom(QXcbAtom::XdndProxy),
-                                                        XCB_ATOM_WINDOW, 0, 1), c);
-    reply = xcb_get_property_reply(c->xcb_connection(), cookie, 0);
+    reply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(),
+                        false, proxy, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1);
 
     if (reply && reply->type == XCB_ATOM_WINDOW) {
-        xcb_window_t p = *((xcb_window_t *)xcb_get_property_value(reply));
+        xcb_window_t p = *((xcb_window_t *)xcb_get_property_value(reply.get()));
         if (proxy != p)
             proxy = 0;
     } else {
         proxy = 0;
     }
 
-    free(reply);
-
     return proxy;
 }
 
@@ -228,28 +223,19 @@ void QXcbDrag::endDrag()
     initiatorWindow.clear();
 }
 
-static xcb_translate_coordinates_reply_t *
-translateCoordinates(QXcbConnection *c, xcb_window_t from, xcb_window_t to, int x, int y)
-{
-    xcb_translate_coordinates_cookie_t cookie =
-            xcb_translate_coordinates(c->xcb_connection(), from, to, x, y);
-    return xcb_translate_coordinates_reply(c->xcb_connection(), cookie, 0);
-}
-
 static
 bool windowInteractsWithPosition(xcb_connection_t *connection, const QPoint & pos, xcb_window_t w, xcb_shape_sk_t shapeType)
 {
     bool interacts = false;
-    xcb_shape_get_rectangles_reply_t *reply = xcb_shape_get_rectangles_reply(connection, xcb_shape_get_rectangles(connection, w, shapeType), NULL);
+    auto reply = Q_XCB_REPLY(xcb_shape_get_rectangles, connection, w, shapeType);
     if (reply) {
-        xcb_rectangle_t *rectangles = xcb_shape_get_rectangles_rectangles(reply);
+        xcb_rectangle_t *rectangles = xcb_shape_get_rectangles_rectangles(reply.get());
         if (rectangles) {
-            const int nRectangles = xcb_shape_get_rectangles_rectangles_length(reply);
+            const int nRectangles = xcb_shape_get_rectangles_rectangles_length(reply.get());
             for (int i = 0; !interacts && i < nRectangles; ++i) {
                 interacts = QRect(rectangles[i].x, rectangles[i].y, rectangles[i].width, rectangles[i].height).contains(pos);
             }
         }
-        free(reply);
     }
 
     return interacts;
@@ -261,33 +247,25 @@ xcb_window_t QXcbDrag::findRealWindow(const QPoint & pos, xcb_window_t w, int md
         return 0;
 
     if (md) {
-        xcb_get_window_attributes_cookie_t cookie = xcb_get_window_attributes(xcb_connection(), w);
-        xcb_get_window_attributes_reply_t *reply = xcb_get_window_attributes_reply(xcb_connection(), cookie, 0);
+        auto reply = Q_XCB_REPLY(xcb_get_window_attributes, xcb_connection(), w);
         if (!reply)
             return 0;
 
         if (reply->map_state != XCB_MAP_STATE_VIEWABLE)
             return 0;
 
-        free(reply);
-
-        xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(xcb_connection(), w);
-        xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(xcb_connection(), gcookie, 0);
+        auto greply = Q_XCB_REPLY(xcb_get_geometry, xcb_connection(), w);
         if (!greply)
             return 0;
 
         QRect windowRect(greply->x, greply->y, greply->width, greply->height);
-        free(greply);
         if (windowRect.contains(pos)) {
             bool windowContainsMouse = !ignoreNonXdndAwareWindows;
             {
-                xcb_get_property_cookie_t cookie =
-                        Q_XCB_CALL(xcb_get_property(xcb_connection(), false, w, connection()->atom(QXcbAtom::XdndAware),
-                                                    XCB_GET_PROPERTY_TYPE_ANY, 0, 0));
-                xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
-
+                auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
+                                         false, w, connection()->atom(QXcbAtom::XdndAware),
+                                         XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
                 bool isAware = reply && reply->type != XCB_NONE;
-                free(reply);
                 if (isAware) {
                     const QPoint relPos = pos - windowRect.topLeft();
                     // When ShapeInput and ShapeBounding are not set they return a single rectangle with the geometry of the window, this is why we
@@ -303,19 +281,16 @@ xcb_window_t QXcbDrag::findRealWindow(const QPoint & pos, xcb_window_t w, int md
                 }
             }
 
-            xcb_query_tree_cookie_t cookie = xcb_query_tree (xcb_connection(), w);
-            xcb_query_tree_reply_t *reply = xcb_query_tree_reply(xcb_connection(), cookie, 0);
-
+            auto reply = Q_XCB_REPLY(xcb_query_tree, xcb_connection(), w);
             if (!reply)
                 return 0;
-            int nc = xcb_query_tree_children_length(reply);
-            xcb_window_t *c = xcb_query_tree_children(reply);
+            int nc = xcb_query_tree_children_length(reply.get());
+            xcb_window_t *c = xcb_query_tree_children(reply.get());
 
             xcb_window_t r = 0;
             for (uint i = nc; !r && i--;)
                 r = findRealWindow(pos - windowRect.topLeft(), c[i], md-1, ignoreNonXdndAwareWindows);
 
-            free(reply);
             if (r)
                 return r;
 
@@ -356,15 +331,14 @@ void QXcbDrag::move(const QPoint &globalPos)
     }
 
     xcb_window_t rootwin = current_virtual_desktop->root();
-    xcb_translate_coordinates_reply_t *translate =
-            ::translateCoordinates(connection(), rootwin, rootwin, globalPos.x(), globalPos.y());
+    auto translate = Q_XCB_REPLY(xcb_translate_coordinates, connection()->xcb_connection(),
+                                 rootwin, rootwin, globalPos.x(), globalPos.y());
     if (!translate)
         return;
 
     xcb_window_t target = translate->child;
     int lx = translate->dst_x;
     int ly = translate->dst_y;
-    free (translate);
 
     if (target && target != rootwin) {
         xcb_window_t src = rootwin;
@@ -372,7 +346,8 @@ void QXcbDrag::move(const QPoint &globalPos)
             DNDDEBUG << "checking target for XdndAware" << target << lx << ly;
 
             // translate coordinates
-            translate = ::translateCoordinates(connection(), src, target, lx, ly);
+            auto translate = Q_XCB_REPLY(xcb_translate_coordinates, connection()->xcb_connection(),
+                                         src, target, lx, ly);
             if (!translate) {
                 target = 0;
                 break;
@@ -381,14 +356,11 @@ void QXcbDrag::move(const QPoint &globalPos)
             ly = translate->dst_y;
             src = target;
             xcb_window_t child = translate->child;
-            free(translate);
 
             // check if it has XdndAware
-            xcb_get_property_cookie_t cookie = Q_XCB_CALL(xcb_get_property(xcb_connection(), false, target,
-                                                          atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0));
-            xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
+            auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, target,
+                                     atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
             bool aware = reply && reply->type != XCB_NONE;
-            free(reply);
             if (aware) {
                 DNDDEBUG << "Found XdndAware on " << target;
                 break;
@@ -422,16 +394,14 @@ void QXcbDrag::move(const QPoint &globalPos)
     int target_version = 1;
 
     if (proxy_target) {
-        xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, proxy_target,
-                                                            atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
-        xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
+        auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
+                                 false, proxy_target,
+                                 atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
         if (!reply || reply->type == XCB_NONE)
             target = 0;
 
-        target_version = *(uint32_t *)xcb_get_property_value(reply);
+        target_version = *(uint32_t *)xcb_get_property_value(reply.get());
         target_version = qMin(xdnd_version, target_version ? target_version : 1);
-
-        free(reply);
     }
 
     if (target != current_target) {
@@ -714,21 +684,19 @@ void QXcbDrag::handleEnter(QPlatformWindow *window, const xcb_client_message_eve
 
     if (event->data.data32[1] & 1) {
         // get the types from XdndTypeList
-        xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, xdnd_dragsource,
-                                                            atom(QXcbAtom::XdndTypelist), XCB_ATOM_ATOM,
-                                                            0, xdnd_max_type);
-        xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
+        auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, xdnd_dragsource,
+                                 atom(QXcbAtom::XdndTypelist), XCB_ATOM_ATOM,
+                                 0, xdnd_max_type);
         if (reply && reply->type != XCB_NONE && reply->format == 32) {
-            int length = xcb_get_property_value_length(reply) / 4;
+            int length = xcb_get_property_value_length(reply.get()) / 4;
             if (length > xdnd_max_type)
                 length = xdnd_max_type;
 
-            xcb_atom_t *atoms = (xcb_atom_t *)xcb_get_property_value(reply);
+            xcb_atom_t *atoms = (xcb_atom_t *)xcb_get_property_value(reply.get());
             xdnd_types.reserve(length);
             for (int i = 0; i < length; ++i)
                 xdnd_types.append(atoms[i]);
         }
-        free(reply);
     } else {
         // get the types from the message
         for(int i = 2; i < 5; i++) {
@@ -1132,28 +1100,20 @@ static xcb_window_t findXdndAwareParent(QXcbConnection *c, xcb_window_t window)
     xcb_window_t target = 0;
     forever {
         // check if window has XdndAware
-        xcb_get_property_cookie_t gpCookie = Q_XCB_CALL(
-            xcb_get_property(c->xcb_connection(), false, window,
-                             c->atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0));
-        xcb_get_property_reply_t *gpReply = xcb_get_property_reply(
-            c->xcb_connection(), gpCookie, 0);
+        auto gpReply = Q_XCB_REPLY(xcb_get_property, c->xcb_connection(), false, window,
+                                   c->atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0);
         bool aware = gpReply && gpReply->type != XCB_NONE;
-        free(gpReply);
         if (aware) {
             target = window;
             break;
         }
 
         // try window's parent
-        xcb_query_tree_cookie_t qtCookie = Q_XCB_CALL(
-            xcb_query_tree_unchecked(c->xcb_connection(), window));
-        xcb_query_tree_reply_t *qtReply = xcb_query_tree_reply(
-            c->xcb_connection(), qtCookie, NULL);
+        auto qtReply = Q_XCB_REPLY_UNCHECKED(xcb_query_tree, c->xcb_connection(), window);
         if (!qtReply)
             break;
         xcb_window_t root = qtReply->root;
         xcb_window_t parent = qtReply->parent;
-        free(qtReply);
         if (window == root)
             break;
         window = parent;