diff --git a/unmanaged.cpp b/unmanaged.cpp
index 09a8526dc..8e1f2dcf1 100644
--- a/unmanaged.cpp
+++ b/unmanaged.cpp
@@ -1,211 +1,211 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "unmanaged.h"
 
 #include "workspace.h"
 #include "effects.h"
 #include "deleted.h"
 #include "utils.h"
 #include "xcbutils.h"
 
 #include <QTimer>
 #include <QDebug>
 #include <QWindow>
 
 #include <xcb/shape.h>
 
 namespace KWin
 {
 
 // window types that are supported as unmanaged (mainly for compositing)
 const NET::WindowTypes SUPPORTED_UNMANAGED_WINDOW_TYPES_MASK = NET::NormalMask | NET::DesktopMask | NET::DockMask
         | NET::ToolbarMask | NET::MenuMask | NET::DialogMask /*| NET::OverrideMask*/ | NET::TopMenuMask
         | NET::UtilityMask | NET::SplashMask | NET::DropdownMenuMask | NET::PopupMenuMask
         | NET::TooltipMask | NET::NotificationMask | NET::ComboBoxMask | NET::DNDIconMask | NET::OnScreenDisplayMask
         | NET::CriticalNotificationMask;
 
 Unmanaged::Unmanaged()
     : Toplevel()
 {
     ready_for_painting = false;
     connect(this, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SIGNAL(geometryChanged()));
     QTimer::singleShot(50, this, SLOT(setReadyForPainting()));
 }
 
 Unmanaged::~Unmanaged()
 {
 }
 
 bool Unmanaged::track(xcb_window_t w)
 {
-    GRAB_SERVER_DURING_CONTEXT
+    XServerGrabber xserverGrabber;
     Xcb::WindowAttributes attr(w);
     Xcb::WindowGeometry geo(w);
     if (attr.isNull() || attr->map_state != XCB_MAP_STATE_VIEWABLE) {
         return false;
     }
     if (attr->_class == XCB_WINDOW_CLASS_INPUT_ONLY) {
         return false;
     }
     if (geo.isNull()) {
         return false;
     }
     setWindowHandles(w);   // the window is also the frame
     Xcb::selectInput(w, attr->your_event_mask | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE);
     geom = geo.rect();
     checkScreen();
     m_visual = attr->visual;
     bit_depth = geo->depth;
     info = new NETWinInfo(connection(), w, rootWindow(),
                           NET::WMWindowType | NET::WMPid,
                           NET::WM2Opacity |
                           NET::WM2WindowRole |
                           NET::WM2WindowClass |
                           NET::WM2OpaqueRegion);
     getResourceClass();
     getWmClientLeader();
     getWmClientMachine();
     if (Xcb::Extensions::self()->isShapeAvailable())
         xcb_shape_select_input(connection(), w, true);
     detectShape(w);
     getWmOpaqueRegion();
     getSkipCloseAnimation();
     setupCompositing();
     if (QWindow *internalWindow = findInternalWindow()) {
         m_outline = internalWindow->property("__kwin_outline").toBool();
     }
     if (effects)
         static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking();
     return true;
 }
 
 void Unmanaged::release(ReleaseReason releaseReason)
 {
     Deleted* del = nullptr;
     if (releaseReason != ReleaseReason::KWinShutsDown) {
         del = Deleted::create(this);
     }
     emit windowClosed(this, del);
     finishCompositing(releaseReason);
     if (!QWidget::find(window()) && releaseReason != ReleaseReason::Destroyed) { // don't affect our own windows
         if (Xcb::Extensions::self()->isShapeAvailable())
             xcb_shape_select_input(connection(), window(), false);
         Xcb::selectInput(window(), XCB_EVENT_MASK_NO_EVENT);
     }
     if (releaseReason != ReleaseReason::KWinShutsDown) {
         workspace()->removeUnmanaged(this);
         addWorkspaceRepaint(del->visibleRect());
         disownDataPassedToDeleted();
         del->unrefWindow();
     }
     deleteUnmanaged(this);
 }
 
 void Unmanaged::deleteUnmanaged(Unmanaged* c)
 {
     delete c;
 }
 
 int Unmanaged::desktop() const
 {
     return NET::OnAllDesktops; // TODO for some window types should be the current desktop?
 }
 
 QStringList Unmanaged::activities() const
 {
     return QStringList();
 }
 
 QVector<VirtualDesktop *> Unmanaged::desktops() const
 {
     return QVector<VirtualDesktop *>();
 }
 
 QPoint Unmanaged::clientPos() const
 {
     return QPoint(0, 0);   // unmanaged windows don't have decorations
 }
 
 QSize Unmanaged::clientSize() const
 {
     return size();
 }
 
 QRect Unmanaged::transparentRect() const
 {
     return QRect(clientPos(), clientSize());
 }
 
 void Unmanaged::debug(QDebug& stream) const
 {
     stream << "\'ID:" << window() << "\'";
 }
 
 NET::WindowType Unmanaged::windowType(bool direct, int supportedTypes) const
 {
     // for unmanaged windows the direct does not make any difference
     // as there are no rules to check and no hacks to apply
     Q_UNUSED(direct)
     if (supportedTypes == 0) {
         supportedTypes = SUPPORTED_UNMANAGED_WINDOW_TYPES_MASK;
     }
     return info->windowType(NET::WindowTypes(supportedTypes));
 }
 
 bool Unmanaged::isOutline() const
 {
     return m_outline;
 }
 
 void Unmanaged::addDamage(const QRegion &damage)
 {
     repaints_region += damage;
     Toplevel::addDamage(damage);
 }
 
 QWindow *Unmanaged::findInternalWindow() const
 {
     const QWindowList windows = kwinApp()->topLevelWindows();
     for (QWindow *w : windows) {
         if (w->winId() == window()) {
             return w;
         }
     }
     return nullptr;
 }
 
 bool Unmanaged::setupCompositing()
 {
     if (!Toplevel::setupCompositing()) {
         return false;
     }
 
     // With unmanaged windows there is a race condition between the client painting the window
     // and us setting up damage tracking.  If the client wins we won't get a damage event even
     // though the window has been painted.  To avoid this we mark the whole window as damaged
     // and schedule a repaint immediately after creating the damage object.
     addDamageFull();
 
     return true;
 }
 
 } // namespace
 
diff --git a/utils.h b/utils.h
index 6c4b339d1..98e420a00 100644
--- a/utils.h
+++ b/utils.h
@@ -1,228 +1,224 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_UTILS_H
 #define KWIN_UTILS_H
 
 // cmake stuff
 #include <config-kwin.h>
 #include <kwinconfig.h>
 // kwin
 #include <kwinglobals.h>
 // Qt
 #include <QLoggingCategory>
 #include <QList>
 #include <QPoint>
 #include <QRect>
 #include <QScopedPointer>
 #include <QProcess>
 // system
 #include <climits>
 Q_DECLARE_LOGGING_CATEGORY(KWIN_CORE)
 Q_DECLARE_LOGGING_CATEGORY(KWIN_VIRTUALKEYBOARD)
 namespace KWin
 {
 
 const QPoint invalidPoint(INT_MIN, INT_MIN);
 
 class Toplevel;
 class Client;
 class Unmanaged;
 class Deleted;
 class Group;
 class Options;
 
 typedef QList< Toplevel* > ToplevelList;
 typedef QList< Client* > ClientList;
 typedef QList< const Client* > ConstClientList;
 typedef QList< Unmanaged* > UnmanagedList;
 typedef QList< Deleted* > DeletedList;
 
 typedef QList< Group* > GroupList;
 
 extern Options* options;
 
 enum Layer {
     UnknownLayer = -1,
     FirstLayer = 0,
     DesktopLayer = FirstLayer,
     BelowLayer,
     NormalLayer,
     DockLayer,
     AboveLayer,
     NotificationLayer, // layer for windows of type notification
     ActiveLayer, // active fullscreen, or active dialog
     CriticalNotificationLayer, // layer for notifications that should be shown even on top of fullscreen
     OnScreenDisplayLayer, // layer for On Screen Display windows such as volume feedback
     UnmanagedLayer, // layer for override redirect windows.
     NumLayers // number of layers, must be last
 };
 
 enum StrutArea {
     StrutAreaInvalid = 0, // Null
     StrutAreaTop     = 1 << 0,
     StrutAreaRight   = 1 << 1,
     StrutAreaBottom  = 1 << 2,
     StrutAreaLeft    = 1 << 3,
     StrutAreaAll     = StrutAreaTop | StrutAreaRight | StrutAreaBottom | StrutAreaLeft
 };
 Q_DECLARE_FLAGS(StrutAreas, StrutArea)
 
 class StrutRect : public QRect
 {
 public:
     explicit StrutRect(QRect rect = QRect(), StrutArea area = StrutAreaInvalid);
     StrutRect(const StrutRect& other);
     StrutRect &operator=(const StrutRect& other);
     inline StrutArea area() const {
         return m_area;
     }
 private:
     StrutArea m_area;
 };
 typedef QVector<StrutRect> StrutRects;
 
 
 enum ShadeMode {
     ShadeNone, // not shaded
     ShadeNormal, // normally shaded - isShade() is true only here
     ShadeHover, // "shaded", but visible due to hover unshade
     ShadeActivated // "shaded", but visible due to alt+tab to the window
 };
 
 /**
  * Maximize mode. These values specify how a window is maximized.
  *
  * @note these values are written to session files, don't change the order
  */
 enum MaximizeMode {
     MaximizeRestore    = 0, ///< The window is not maximized in any direction.
     MaximizeVertical   = 1, ///< The window is maximized vertically.
     MaximizeHorizontal = 2, ///< The window is maximized horizontally.
     /// Equal to @p MaximizeVertical | @p MaximizeHorizontal
     MaximizeFull = MaximizeVertical | MaximizeHorizontal
 };
 
 inline
 MaximizeMode operator^(MaximizeMode m1, MaximizeMode m2)
 {
     return MaximizeMode(int(m1) ^ int(m2));
 }
 
 enum class QuickTileFlag {
     None        = 0,
     Left        = 1 << 0,
     Right       = 1 << 1,
     Top         = 1 << 2,
     Bottom      = 1 << 3,
     Horizontal  = Left | Right,
     Vertical    = Top | Bottom,
     Maximize    = Left | Right | Top | Bottom,
 };
 Q_DECLARE_FLAGS(QuickTileMode, QuickTileFlag)
 
 template <typename T> using ScopedCPointer = QScopedPointer<T, QScopedPointerPodDeleter>;
 
 void KWIN_EXPORT updateXTime();
 void KWIN_EXPORT grabXServer();
 void KWIN_EXPORT ungrabXServer();
 bool KWIN_EXPORT grabXKeyboard(xcb_window_t w = XCB_WINDOW_NONE);
 void KWIN_EXPORT ungrabXKeyboard();
 
 /**
  * Small helper class which performs grabXServer in the ctor and
  * ungrabXServer in the dtor. Use this class to ensure that grab and
  * ungrab are matched.
- *
- * To simplify usage consider using the macro GRAB_SERVER_DURING_CONTEXT
  */
 class XServerGrabber
 {
 public:
     XServerGrabber() {
         grabXServer();
     }
     ~XServerGrabber() {
         ungrabXServer();
     }
 };
 
-#define GRAB_SERVER_DURING_CONTEXT XServerGrabber xserverGrabber;
-
 // the docs say it's UrgencyHint, but it's often #defined as XUrgencyHint
 #ifndef UrgencyHint
 #define UrgencyHint XUrgencyHint
 #endif
 
 // converting between X11 mouse/keyboard state mask and Qt button/keyboard states
 Qt::MouseButton x11ToQtMouseButton(int button);
 Qt::MouseButton KWIN_EXPORT x11ToQtMouseButton(int button);
 Qt::MouseButtons KWIN_EXPORT x11ToQtMouseButtons(int state);
 Qt::KeyboardModifiers KWIN_EXPORT x11ToQtKeyboardModifiers(int state);
 
 /**
  * Separate the concept of an unet QPoint and 0,0
  */
 class ClearablePoint
 {
 public:
     inline bool isValid() const {
         return m_valid;
     }
 
     inline void clear(){
         m_valid = false;
     }
 
     inline void setPoint(const QPoint &point) {
         m_point = point; m_valid = true;
     }
 
     inline QPoint point() const {
         return m_point;
     }
 
 private:
     QPoint m_point;
     bool m_valid = false;
 };
 
 /**
  * QProcess subclass which unblocks SIGUSR in the child process.
  */
 class KWIN_EXPORT Process : public QProcess
 {
     Q_OBJECT
 public:
     explicit Process(QObject *parent = nullptr);
     ~Process() override;
 
 protected:
     void setupChildProcess() override;
 };
 
 } // namespace
 
 // Must be outside namespace
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::StrutAreas)
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::QuickTileMode)
 
 #endif