DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_X11Util_h
#define mozilla_X11Util_h

// Utilities common to all X clients, regardless of UI toolkit.

#if defined(MOZ_WIDGET_GTK)
#  include <gdk/gdk.h>
#  include <gdk/gdkx.h>
#  include "X11UndefineNone.h"
#else
#  error Unknown toolkit
#endif

#include <string.h>          // for memset
#include "mozilla/Scoped.h"  // for SCOPED_TEMPLATE

namespace mozilla {

/**
 * Return the default X Display created and used by the UI toolkit.
 */
inline Display* DefaultXDisplay() {
#if defined(MOZ_WIDGET_GTK)
  return GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
#endif
}

/**
 * Sets *aVisual to point to aDisplay's Visual struct corresponding to
 * aVisualID, and *aDepth to its depth.  When aVisualID is None, these are set
 * to nullptr and 0 respectively.  Both out-parameter pointers are assumed
 * non-nullptr.
 */
void FindVisualAndDepth(Display* aDisplay, VisualID aVisualID, Visual** aVisual,
                        int* aDepth);

/**
 * Ensure that all X requests have been processed.
 *
 * This is similar to XSync, but doesn't need a round trip if the previous
 * request was synchronous or if events have been received since the last
 * request.  Subsequent FinishX calls will be noops if there have been no
 * intermediate requests.
 */

void FinishX(Display* aDisplay);

/**
 * Invoke XFree() on a pointer to memory allocated by Xlib (if the
 * pointer is nonnull) when this class goes out of scope.
 */
template <typename T>
struct ScopedXFreePtrTraits {
  typedef T* type;
  static T* empty() { return nullptr; }
  static void release(T* ptr) {
    if (ptr != nullptr) XFree(ptr);
  }
};
SCOPED_TEMPLATE(ScopedXFree, ScopedXFreePtrTraits)

/**
 * On construction, set a graceful X error handler that doesn't crash the
 * application and records X errors. On destruction, restore the X error handler
 * to what it was before construction.
 *
 * The SyncAndGetError() method allows to know whether a X error occurred,
 * optionally allows to get the full XErrorEvent, and resets the recorded X
 * error state so that a single X error will be reported only once.
 *
 * Nesting is correctly handled: multiple nested ScopedXErrorHandler's don't
 * interfere with each other's state. However, if SyncAndGetError is not called
 * on the nested ScopedXErrorHandler, then any X errors caused by X calls made
 * while the nested ScopedXErrorHandler was in place may then be caught by the
 * other ScopedXErrorHandler. This is just a result of X being asynchronous and
 * us not doing any implicit syncing: the only method in this class what causes
 * syncing is SyncAndGetError().
 *
 * This class is not thread-safe at all. It is assumed that only one thread is
 * using any ScopedXErrorHandler's. Given that it's not used on Mac, it should
 * be easy to make it thread-safe by using thread-local storage with __thread.
 */
class ScopedXErrorHandler {
 public:
  // trivial wrapper around XErrorEvent, just adding ctor initializing by zero.
  struct ErrorEvent {
    XErrorEvent mError;

    ErrorEvent() { memset(this, 0, sizeof(ErrorEvent)); }
  };

 private:
  // this ScopedXErrorHandler's ErrorEvent object
  ErrorEvent mXError;

  // static pointer for use by the error handler
  static ErrorEvent* sXErrorPtr;

  // what to restore sXErrorPtr to on destruction
  ErrorEvent* mOldXErrorPtr;

  // what to restore the error handler to on destruction
  int (*mOldErrorHandler)(Display*, XErrorEvent*);

 public:
  static int ErrorHandler(Display*, XErrorEvent* ev);

  /**
   * @param aAllowOffMainThread whether to warn if used off main thread
   */
  explicit ScopedXErrorHandler(bool aAllowOffMainThread = false);

  ~ScopedXErrorHandler();

  /** \returns true if a X error occurred since the last time this method was
   * called on this ScopedXErrorHandler object, or since the creation of this
   * ScopedXErrorHandler object if this method was never called on it.
   *
   * \param ev this optional parameter, if set, will be filled with the
   * XErrorEvent object. If multiple errors occurred, the first one will be
   * returned.
   */
  bool SyncAndGetError(Display* dpy, XErrorEvent* ev = nullptr);
};

class OffMainThreadScopedXErrorHandler : public ScopedXErrorHandler {
 public:
  OffMainThreadScopedXErrorHandler() : ScopedXErrorHandler(true) {}
};

}  // namespace mozilla

#endif  // mozilla_X11Util_h