Move XID, XDisplay, GetXDisplay and a few other types to ui/gfx/x/x11_types.h

ui/base/x/x11_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 54 matching lines @@
 #include "ui/gfx/gdk_compat.h"
 #include "ui/gfx/gtk_compat.h"
 #endif
 
 namespace ui {
 
 namespace {
 
 // Used to cache the XRenderPictFormat for a visual/display pair.
 struct CachedPictFormat {
-  bool equals(Display* display, Visual* visual) const {
+  bool equals(XDisplay* display, Visual* visual) const {
     return display == this->display && visual == this->visual;
   }
 
-  Display* display;
+  XDisplay* display;
   Visual* visual;
   XRenderPictFormat* format;
 };
 
 typedef std::list<CachedPictFormat> CachedPictFormats;
 
 // Returns the cache of pict formats.
 CachedPictFormats* get_cached_pict_formats() {
   static CachedPictFormats* formats = NULL;
   if (!formats)
     formats = new CachedPictFormats();
   return formats;
 }
 
 // Maximum number of CachedPictFormats we keep around.
 const size_t kMaxCacheSize = 5;
 
-int DefaultX11ErrorHandler(Display* d, XErrorEvent* e) {
+int DefaultX11ErrorHandler(XDisplay* d, XErrorEvent* e) {
   if (base::MessageLoop::current()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&LogErrorEventDescription, d, *e));
   } else {
     LOG(ERROR)
         << "X error received: "
         << "serial " << e->serial << ", "
         << "error_code " << static_cast<int>(e->error_code) << ", "
         << "request_code " << static_cast<int>(e->request_code) << ", "
         << "minor_code " << static_cast<int>(e->minor_code);
   }
   return 0;
 }
 
-int DefaultX11IOErrorHandler(Display* d) {
+int DefaultX11IOErrorHandler(XDisplay* d) {
   // If there's an IO error it likely means the X server has gone away
   LOG(ERROR) << "X IO error received (X server probably went away)";
   _exit(1);
 }
 
 // Note: The caller should free the resulting value data.
 bool GetProperty(XID window, const std::string& property_name, long max_length,
                  Atom* type, int* format, unsigned long* num_items,
                  unsigned char** property) {
   Atom property_atom = GetAtom(property_name.c_str());
   unsigned long remaining_bytes = 0;
-  return XGetWindowProperty(GetXDisplay(),
+  return XGetWindowProperty(gfx::GetXDisplay(),
                             window,
                             property_atom,
                             0,          // offset into property data to read
                             max_length, // max length to get
                             False,      // deleted
                             AnyPropertyType,
                             type,
                             format,
                             num_items,
                             &remaining_bytes,
@@ skipping 17 matching lines @@
     case ui::ET_KEY_RELEASED:
       return KeyRelease;
     default:
       return 0;
   }
 }
 
 // Converts KeyboardCode to XKeyEvent keycode.
 unsigned int XKeyEventKeyCode(ui::KeyboardCode key_code,
                               int flags,
-                              Display* display) {
+                              XDisplay* display) {
   const int keysym = XKeysymForWindowsKeyCode(key_code,
                                               flags & ui::EF_SHIFT_DOWN);
   // Tests assume the keycode for XK_less is equal to the one of XK_comma,
   // but XKeysymToKeycode returns 94 for XK_less while it returns 59 for
   // XK_comma. Here we convert the value for XK_less to the value for XK_comma.
   return (keysym == XK_less) ? 59 : XKeysymToKeycode(display, keysym);
 }
 
 // A process wide singleton that manages the usage of X cursors.
 class XCursorCache {
  public:
   XCursorCache() {}
   ~XCursorCache() {
     Clear();
   }
 
   ::Cursor GetCursor(int cursor_shape) {
     // Lookup cursor by attempting to insert a null value, which avoids
     // a second pass through the map after a cache miss.
     std::pair<std::map<int, ::Cursor>::iterator, bool> it = cache_.insert(
         std::make_pair(cursor_shape, 0));
     if (it.second) {
-      Display* display = base::MessagePumpForUI::GetDefaultXDisplay();
+      XDisplay* display = base::MessagePumpForUI::GetDefaultXDisplay();
       it.first->second = XCreateFontCursor(display, cursor_shape);
     }
     return it.first->second;
   }
 
   void Clear() {
-    Display* display = base::MessagePumpForUI::GetDefaultXDisplay();
+    XDisplay* display = base::MessagePumpForUI::GetDefaultXDisplay();
     for (std::map<int, ::Cursor>::iterator it =
         cache_.begin(); it != cache_.end(); ++it) {
       XFreeCursor(display, it->second);
     }
     cache_.clear();
   }
 
  private:
   // Maps X11 font cursor shapes to Cursor IDs.
   std::map<int, ::Cursor> cache_;
@@ skipping 33 matching lines @@
 
  private:
   friend struct DefaultSingletonTraits<XCustomCursorCache>;
 
   class XCustomCursor {
    public:
     // This takes ownership of the image.
     XCustomCursor(XcursorImage* image)
         : image_(image),
           ref_(1) {
-      cursor_ = XcursorImageLoadCursor(GetXDisplay(), image);
+      cursor_ = XcursorImageLoadCursor(gfx::GetXDisplay(), image);
     }
 
     ~XCustomCursor() {
       XcursorImageDestroy(image_);
-      XFreeCursor(GetXDisplay(), cursor_);
+      XFreeCursor(gfx::GetXDisplay(), cursor_);
     }
 
     ::Cursor cursor() const { return cursor_; }
 
     void Ref() {
       ++ref_;
     }
 
     // Returns true if the cursor was destroyed because of the unref.
     bool Unref() {
@@ skipping 23 matching lines @@
 #endif  // defined(USE_AURA)
 
 // A singleton object that remembers remappings of mouse buttons.
 class XButtonMap {
  public:
   static XButtonMap* GetInstance() {
     return Singleton<XButtonMap>::get();
   }
 
   void UpdateMapping() {
-    count_ = XGetPointerMapping(ui::GetXDisplay(), map_, arraysize(map_));
+    count_ = XGetPointerMapping(gfx::GetXDisplay(), map_, arraysize(map_));
   }
 
   int GetMappedButton(int button) {
     return button > 0 && button <= count_ ? map_[button - 1] : button;
   }
 
  private:
   friend struct DefaultSingletonTraits<XButtonMap>;
 
   XButtonMap() {
     UpdateMapping();
   }
 
   ~XButtonMap() {}
 
   unsigned char map_[256];
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(XButtonMap);
 };
 
 bool IsShapeAvailable() {
   int dummy;
   static bool is_shape_available =
-    XShapeQueryExtension(ui::GetXDisplay(), &dummy, &dummy);
+    XShapeQueryExtension(gfx::GetXDisplay(), &dummy, &dummy);
   return is_shape_available;
 
 }
 
 }  // namespace
 
 bool XDisplayExists() {
-  return (GetXDisplay() != NULL);
+  return (gfx::GetXDisplay() != NULL);
 }
 
-Display* GetXDisplay() {
-  return base::MessagePumpForUI::GetDefaultXDisplay();
-}
-
-static SharedMemorySupport DoQuerySharedMemorySupport(Display* dpy) {
+static SharedMemorySupport DoQuerySharedMemorySupport(XDisplay* dpy) {
   int dummy;
   Bool pixmaps_supported;
   // Query the server's support for XSHM.
   if (!XShmQueryVersion(dpy, &dummy, &dummy, &pixmaps_supported))
     return SHARED_MEMORY_NONE;
 
 #if defined(OS_FREEBSD)
   // On FreeBSD we can't access the shared memory after it was marked for
   // deletion, unless this behaviour is explicitly enabled by the user.
   // In case it's not enabled disable shared memory support.
@@ skipping 36 matching lines @@
     LOG(WARNING) << "X failed to attach to shared memory segment " << shmkey;
     return SHARED_MEMORY_NONE;
   }
 
   VLOG(1) << "X attached to shared memory segment " << shmkey;
 
   XShmDetach(dpy, &shminfo);
   return pixmaps_supported ? SHARED_MEMORY_PIXMAP : SHARED_MEMORY_PUTIMAGE;
 }
 
-SharedMemorySupport QuerySharedMemorySupport(Display* dpy) {
+SharedMemorySupport QuerySharedMemorySupport(XDisplay* dpy) {
   static SharedMemorySupport shared_memory_support = SHARED_MEMORY_NONE;
   static bool shared_memory_support_cached = false;
 
   if (shared_memory_support_cached)
     return shared_memory_support;
 
   shared_memory_support = DoQuerySharedMemorySupport(dpy);
   shared_memory_support_cached = true;
 
   return shared_memory_support;
 }
 
-bool QueryRenderSupport(Display* dpy) {
+bool QueryRenderSupport(XDisplay* dpy) {
   static bool render_supported = false;
   static bool render_supported_cached = false;
 
   if (render_supported_cached)
     return render_supported;
 
   // We don't care about the version of Xrender since all the features which
   // we use are included in every version.
   int dummy;
   render_supported = XRenderQueryExtension(dpy, &dummy, &dummy);
   render_supported_cached = true;
 
   return render_supported;
 }
 
-int GetDefaultScreen(Display* display) {
+int GetDefaultScreen(XDisplay* display) {
   return XDefaultScreen(display);
 }
 
 ::Cursor GetXCursor(int cursor_shape) {
   if (!cursor_cache)
     cursor_cache = new XCursorCache;
   return cursor_cache->GetCursor(cursor_shape);
 }
 
 void ResetXCursorCache() {
@@ skipping 54 matching lines @@
   }
 
   return image;
 }
 
 
 int CoalescePendingMotionEvents(const XEvent* xev,
                                 XEvent* last_event) {
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
   int num_coalesced = 0;
-  Display* display = xev->xany.display;
+  XDisplay* display = xev->xany.display;
   int event_type = xev->xgeneric.evtype;
 
   DCHECK_EQ(event_type, XI_Motion);
 
   while (XPending(display)) {
     XEvent next_event;
     XPeekEvent(display, &next_event);
 
     // If we can't get the cookie, abort the check.
     if (!XGetEventData(next_event.xgeneric.display, &next_event.xcookie))
@@ skipping 49 matching lines @@
         ui::EventTimeFromNative(const_cast<XEvent*>(xev));
     UMA_HISTOGRAM_COUNTS_10000("Event.CoalescedCount.Mouse", num_coalesced);
     UMA_HISTOGRAM_TIMES("Event.CoalescedLatency.Mouse", delta);
   }
   return num_coalesced;
 }
 #endif
 
 void HideHostCursor() {
   CR_DEFINE_STATIC_LOCAL(XScopedCursor, invisible_cursor,
-                         (CreateInvisibleCursor(), ui::GetXDisplay()));
-  XDefineCursor(ui::GetXDisplay(), DefaultRootWindow(ui::GetXDisplay()),
+                         (CreateInvisibleCursor(), gfx::GetXDisplay()));
+  XDefineCursor(gfx::GetXDisplay(), DefaultRootWindow(gfx::GetXDisplay()),
                 invisible_cursor.get());
 }
 
 ::Cursor CreateInvisibleCursor() {
-  Display* xdisplay = ui::GetXDisplay();
+  XDisplay* xdisplay = gfx::GetXDisplay();
   ::Cursor invisible_cursor;
   char nodata[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   XColor black;
   black.red = black.green = black.blue = 0;
   Pixmap blank = XCreateBitmapFromData(xdisplay,
                                        DefaultRootWindow(xdisplay),
                                        nodata, 8, 8);
   invisible_cursor = XCreatePixmapCursor(xdisplay, blank, blank,
                                          &black, &black, 0, 0);
   XFreePixmap(xdisplay, blank);
   return invisible_cursor;
 }
 
 XID GetX11RootWindow() {
-  return DefaultRootWindow(GetXDisplay());
+  return DefaultRootWindow(gfx::GetXDisplay());
 }
 
 bool GetCurrentDesktop(int* desktop) {
   return GetIntProperty(GetX11RootWindow(), "_NET_CURRENT_DESKTOP", desktop);
 }
 
 #if defined(TOOLKIT_GTK)
 XID GetX11WindowFromGtkWidget(GtkWidget* widget) {
   return GDK_WINDOW_XID(gtk_widget_get_window(widget));
 }
@@ skipping 16 matching lines @@
 }
 
 void* GetVisualFromGtkWidget(GtkWidget* widget) {
   return GDK_VISUAL_XVISUAL(gtk_widget_get_visual(widget));
 }
 #endif  // defined(TOOLKIT_GTK)
 
 void SetHideTitlebarWhenMaximizedProperty(XID window,
                                           HideTitlebarWhenMaximized property) {
   uint32 hide = property;
-  XChangeProperty(GetXDisplay(),
+  XChangeProperty(gfx::GetXDisplay(),
       window,
       GetAtom("_GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"),
       XA_CARDINAL,
       32,  // size in bits
       PropModeReplace,
       reinterpret_cast<unsigned char*>(&hide),
       1);
 }
 
 void ClearX11DefaultRootWindow() {
-  Display* display = GetXDisplay();
+  XDisplay* display = gfx::GetXDisplay();
   XID root_window = GetX11RootWindow();
   gfx::Rect root_bounds;
   if (!GetWindowRect(root_window, &root_bounds)) {
     LOG(ERROR) << "Failed to get the bounds of the X11 root window";
     return;
   }
 
   XGCValues gc_values = {0};
   gc_values.foreground = BlackPixel(display, DefaultScreen(display));
   GC gc = XCreateGC(display, root_window, GCForeground, &gc_values);
   XFillRectangle(display, root_window, gc,
                  root_bounds.x(),
                  root_bounds.y(),
                  root_bounds.width(),
                  root_bounds.height());
   XFreeGC(display, gc);
 }
 
-int BitsPerPixelForPixmapDepth(Display* dpy, int depth) {
+int BitsPerPixelForPixmapDepth(XDisplay* dpy, int depth) {
   int count;
   XPixmapFormatValues* formats = XListPixmapFormats(dpy, &count);
   if (!formats)
     return -1;
 
   int bits_per_pixel = -1;
   for (int i = 0; i < count; ++i) {
     if (formats[i].depth == depth) {
       bits_per_pixel = formats[i].bits_per_pixel;
       break;
     }
   }
 
   XFree(formats);
   return bits_per_pixel;
 }
 
 bool IsWindowVisible(XID window) {
   XWindowAttributes win_attributes;
-  if (!XGetWindowAttributes(GetXDisplay(), window, &win_attributes))
+  if (!XGetWindowAttributes(gfx::GetXDisplay(), window, &win_attributes))
     return false;
   if (win_attributes.map_state != IsViewable)
     return false;
   // Some compositing window managers (notably kwin) do not actually unmap
   // windows on desktop switch, so we also must check the current desktop.
   int window_desktop, current_desktop;
   return (!GetWindowDesktop(window, &window_desktop) ||
           !GetCurrentDesktop(&current_desktop) ||
           window_desktop == kAllDesktops ||
           window_desktop == current_desktop);
 }
 
 bool GetWindowRect(XID window, gfx::Rect* rect) {
   Window root, child;
   int x, y;
   unsigned int width, height;
   unsigned int border_width, depth;
 
-  if (!XGetGeometry(GetXDisplay(), window, &root, &x, &y,
+  if (!XGetGeometry(gfx::GetXDisplay(), window, &root, &x, &y,
                     &width, &height, &border_width, &depth))
     return false;
 
-  if (!XTranslateCoordinates(GetXDisplay(), window, root,
+  if (!XTranslateCoordinates(gfx::GetXDisplay(), window, root,
                              0, 0, &x, &y, &child))
     return false;
 
   *rect = gfx::Rect(x, y, width, height);
   return true;
 }
 
 
 bool WindowContainsPoint(XID window, gfx::Point screen_loc) {
   gfx::Rect window_rect;
   if (!GetWindowRect(window, &window_rect))
     return false;
 
   if (!window_rect.Contains(screen_loc))
     return false;
 
   if (!IsShapeAvailable())
     return true;
 
   // According to http://www.x.org/releases/X11R7.6/doc/libXext/shapelib.html,
   // if an X display supports the shape extension the bounds of a window are
   // defined as the intersection of the window bounds and the interior
   // rectangles. This means to determine if a point is inside a window for the
   // purpose of input handling we have to check the rectangles in the ShapeInput
   // list.
   int dummy;
   int input_rects_size = 0;
   XRectangle* input_rects = XShapeGetRectangles(
-      ui::GetXDisplay(), window, ShapeInput, &input_rects_size, &dummy);
+      gfx::GetXDisplay(), window, ShapeInput, &input_rects_size, &dummy);
   if (!input_rects)
     return true;
   bool is_in_input_rects = false;
   for (int i = 0; i < input_rects_size; ++i) {
     // The ShapeInput rects appear to be in window space, so we have to
     // translate by the window_rect's offset to map to screen space.
     gfx::Rect input_rect =
         gfx::Rect(input_rects[i].x + window_rect.x(),
                   input_rects[i].y + window_rect.y(),
                   input_rects[i].width, input_rects[i].height);
@@ skipping 27 matching lines @@
                            scoped_refptr<base::RefCountedMemory>* out_data,
                            size_t* out_data_bytes,
                            size_t* out_data_items,
                            Atom* out_type) {
   // Retrieve the data from our window.
   unsigned long nitems = 0;
   unsigned long nbytes = 0;
   Atom prop_type = None;
   int prop_format = 0;
   unsigned char* property_data = NULL;
-  if (XGetWindowProperty(GetXDisplay(), window, property,
+  if (XGetWindowProperty(gfx::GetXDisplay(), window, property,
                          0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
                          AnyPropertyType, &prop_type, &prop_format,
                          &nitems, &nbytes, &property_data) != Success) {
     return false;
   }
 
   if (prop_type == None)
     return false;
 
   size_t bytes = 0;
@@ skipping 165 matching lines @@
   DCHECK(!value.empty());
   Atom name_atom = GetAtom(name.c_str());
   Atom type_atom = GetAtom(type.c_str());
 
   // XChangeProperty() expects values of type 32 to be longs.
   scoped_ptr<long[]> data(new long[value.size()]);
   for (size_t i = 0; i < value.size(); ++i)
     data[i] = value[i];
 
   X11ErrorTracker err_tracker;
-  XChangeProperty(ui::GetXDisplay(),
+  XChangeProperty(gfx::GetXDisplay(),
                   window,
                   name_atom,
                   type_atom,
                   32,  // size in bits of items in 'value'
                   PropModeReplace,
                   reinterpret_cast<const unsigned char*>(data.get()),
                   value.size());  // num items
   return !err_tracker.FoundNewError();
 }
 
 bool SetAtomArrayProperty(XID window,
                           const std::string& name,
                           const std::string& type,
                           const std::vector<Atom>& value) {
   DCHECK(!value.empty());
   Atom name_atom = GetAtom(name.c_str());
   Atom type_atom = GetAtom(type.c_str());
 
   // XChangeProperty() expects values of type 32 to be longs.
   scoped_ptr<Atom[]> data(new Atom[value.size()]);
   for (size_t i = 0; i < value.size(); ++i)
     data[i] = value[i];
 
   X11ErrorTracker err_tracker;
-  XChangeProperty(ui::GetXDisplay(),
+  XChangeProperty(gfx::GetXDisplay(),
                   window,
                   name_atom,
                   type_atom,
                   32,  // size in bits of items in 'value'
                   PropModeReplace,
                   reinterpret_cast<const unsigned char*>(data.get()),
                   value.size());  // num items
   return !err_tracker.FoundNewError();
 }
 
 Atom GetAtom(const char* name) {
 #if defined(TOOLKIT_GTK)
   return gdk_x11_get_xatom_by_name_for_display(
       gdk_display_get_default(), name);
 #else
   // TODO(derat): Cache atoms to avoid round-trips to the server.
-  return XInternAtom(GetXDisplay(), name, false);
+  return XInternAtom(gfx::GetXDisplay(), name, false);
 #endif
 }
 
-void SetWindowClassHint(Display* display,
+void SetWindowClassHint(XDisplay* display,
                         XID window,
                         std::string res_name,
                         std::string res_class) {
   XClassHint class_hints;
   // const_cast is safe because XSetClassHint does not modify the strings.
   // Just to be safe, the res_name and res_class parameters are local copies,
   // not const references.
   class_hints.res_name = const_cast<char*>(res_name.c_str());
   class_hints.res_class = const_cast<char*>(res_class.c_str());
   XSetClassHint(display, window, &class_hints);
 }
 
 XID GetParentWindow(XID window) {
   XID root = None;
   XID parent = None;
   XID* children = NULL;
   unsigned int num_children = 0;
-  XQueryTree(GetXDisplay(), window, &root, &parent, &children, &num_children);
+  XQueryTree(gfx::GetXDisplay(), window, &root, &parent, &children, &num_children);
   if (children)
     XFree(children);
   return parent;
 }
 
 XID GetHighestAncestorWindow(XID window, XID root) {
   while (true) {
     XID parent = GetParentWindow(window);
     if (parent == None)
       return None;
     if (parent == root)
       return window;
     window = parent;
   }
 }
 
 bool GetWindowDesktop(XID window, int* desktop) {
   return GetIntProperty(window, "_NET_WM_DESKTOP", desktop);
 }
 
-std::string GetX11ErrorString(Display* display, int err) {
+std::string GetX11ErrorString(XDisplay* display, int err) {
   char buffer[256];
   XGetErrorText(display, err, buffer, arraysize(buffer));
   return buffer;
 }
 
 // Returns true if |window| is a named window.
 bool IsWindowNamed(XID window) {
   XTextProperty prop;
-  if (!XGetWMName(GetXDisplay(), window, &prop) || !prop.value)
+  if (!XGetWMName(gfx::GetXDisplay(), window, &prop) || !prop.value)
     return false;
 
   XFree(prop.value);
   return true;
 }
 
 bool EnumerateChildren(EnumerateWindowsDelegate* delegate, XID window,
                        const int max_depth, int depth) {
   if (depth > max_depth)
     return false;
 
   XID root, parent, *children;
   unsigned int num_children;
-  int status = XQueryTree(GetXDisplay(), window, &root, &parent, &children,
+  int status = XQueryTree(gfx::GetXDisplay(), window, &root, &parent, &children,
                           &num_children);
   if (status == 0)
     return false;
 
   std::vector<XID> windows;
   for (int i = static_cast<int>(num_children) - 1; i >= 0; i--)
     windows.push_back(children[i]);
 
   XFree(children);
 
@@ skipping 71 matching lines @@
   if (data)
     XFree(data);
 
   return result;
 }
 
 void RestackWindow(XID window, XID sibling, bool above) {
   XWindowChanges changes;
   changes.sibling = sibling;
   changes.stack_mode = above ? Above : Below;
-  XConfigureWindow(GetXDisplay(), window, CWSibling | CWStackMode, &changes);
+  XConfigureWindow(gfx::GetXDisplay(), window, CWSibling | CWStackMode, &changes);
 }
 
-XSharedMemoryId AttachSharedMemory(Display* display, int shared_memory_key) {
+XSharedMemoryId AttachSharedMemory(XDisplay* display, int shared_memory_key) {
   DCHECK(QuerySharedMemorySupport(display));
 
   XShmSegmentInfo shminfo;
   memset(&shminfo, 0, sizeof(shminfo));
   shminfo.shmid = shared_memory_key;
 
   // This function is only called if QuerySharedMemorySupport returned true. In
   // which case we've already succeeded in having the X server attach to one of
   // our shared memory segments.
   if (!XShmAttach(display, &shminfo)) {
     LOG(WARNING) << "X failed to attach to shared memory segment "
                  << shminfo.shmid;
     NOTREACHED();
   } else {
     VLOG(1) << "X attached to shared memory segment " << shminfo.shmid;
   }
 
   return shminfo.shmseg;
 }
 
-void DetachSharedMemory(Display* display, XSharedMemoryId shmseg) {
+void DetachSharedMemory(XDisplay* display, XSharedMemoryId shmseg) {
   DCHECK(QuerySharedMemorySupport(display));
 
   XShmSegmentInfo shminfo;
   memset(&shminfo, 0, sizeof(shminfo));
   shminfo.shmseg = shmseg;
 
   if (!XShmDetach(display, &shminfo))
     NOTREACHED();
 }
 
 bool CopyAreaToCanvas(XID drawable,
                       gfx::Rect source_bounds,
                       gfx::Point dest_offset,
                       gfx::Canvas* canvas) {
   ui::XScopedImage scoped_image(
-      XGetImage(GetXDisplay(), drawable,
+      XGetImage(gfx::GetXDisplay(), drawable,
                 source_bounds.x(), source_bounds.y(),
                 source_bounds.width(), source_bounds.height(),
                 AllPlanes, ZPixmap));
   XImage* image = scoped_image.get();
   if (!image) {
     LOG(ERROR) << "XGetImage failed";
     return false;
   }
 
   if (image->bits_per_pixel == 32) {
@@ skipping 23 matching lines @@
     image_skia.AddRepresentation(image_rep);
     canvas->DrawImageInt(image_skia, dest_offset.x(), dest_offset.y());
   } else {
     NOTIMPLEMENTED() << "Unsupported bits-per-pixel " << image->bits_per_pixel;
     return false;
   }
 
   return true;
 }
 
-XID CreatePictureFromSkiaPixmap(Display* display, XID pixmap) {
+XID CreatePictureFromSkiaPixmap(XDisplay* display, XID pixmap) {
   XID picture = XRenderCreatePicture(
       display, pixmap, GetRenderARGB32Format(display), 0, NULL);
 
   return picture;
 }
 
-void PutARGBImage(Display* display,
+void PutARGBImage(XDisplay* display,
                   void* visual, int depth,
                   XID pixmap, void* pixmap_gc,
                   const uint8* data,
                   int width, int height) {
   PutARGBImage(display,
                visual, depth,
                pixmap, pixmap_gc,
                data, width, height,
                0, 0, // src_x, src_y
                0, 0, // dst_x, dst_y
                width, height);
 }
 
-void PutARGBImage(Display* display,
+void PutARGBImage(XDisplay* display,
                   void* visual, int depth,
                   XID pixmap, void* pixmap_gc,
                   const uint8* data,
                   int data_width, int data_height,
                   int src_x, int src_y,
                   int dst_x, int dst_y,
                   int copy_width, int copy_height) {
   // TODO(scherkus): potential performance impact... consider passing in as a
   // parameter.
   int pixmap_bpp = BitsPerPixelForPixmapDepth(display, depth);
@@ skipping 84 matching lines @@
               src_x, src_y, dst_x, dst_y,
               copy_width, copy_height);
     free(orig_bitmap16);
   } else {
     LOG(FATAL) << "Sorry, we don't support your visual depth without "
                   "Xrender support (depth:" << depth
                << " bpp:" << pixmap_bpp << ")";
   }
 }
 
-void FreePicture(Display* display, XID picture) {
+void FreePicture(XDisplay* display, XID picture) {
   XRenderFreePicture(display, picture);
 }
 
-void FreePixmap(Display* display, XID pixmap) {
+void FreePixmap(XDisplay* display, XID pixmap) {
   XFreePixmap(display, pixmap);
 }
 
 bool GetWindowManagerName(std::string* wm_name) {
   DCHECK(wm_name);
   int wm_window = 0;
   if (!GetIntProperty(GetX11RootWindow(),
                       "_NET_SUPPORTING_WM_CHECK",
                       &wm_window)) {
     return false;
@@ skipping 65 matching lines @@
     return false;
 
   XEvent event;
   event.xclient.type = ClientMessage;
   event.xclient.window = window;
   event.xclient.message_type = GetAtom("_NET_WM_DESKTOP");
   event.xclient.format = 32;
   event.xclient.data.l[0] = desktop;
   event.xclient.data.l[1] = 1;  // source indication
 
-  int result = XSendEvent(GetXDisplay(), GetX11RootWindow(), False,
+  int result = XSendEvent(gfx::GetXDisplay(), GetX11RootWindow(), False,
                           SubstructureNotifyMask, &event);
   return result == Success;
 }
 
 void SetDefaultX11ErrorHandlers() {
   SetX11ErrorHandlers(NULL, NULL);
 }
 
 bool IsX11WindowFullScreen(XID window) {
   // If _NET_WM_STATE_FULLSCREEN is in _NET_SUPPORTED, use the presence or
@@ skipping 30 matching lines @@
   return monitor_rect.x == window_rect.x() &&
          monitor_rect.y == window_rect.y() &&
          monitor_rect.width == window_rect.width() &&
          monitor_rect.height == window_rect.height();
 #else
   // We can't use gfx::Screen here because we don't have an aura::Window. So
   // instead just look at the size of the default display.
   //
   // TODO(erg): Actually doing this correctly would require pulling out xrandr,
   // which we don't even do in the desktop screen yet.
-  ::Display* display = ui::GetXDisplay();
+  ::XDisplay* display = gfx::GetXDisplay();
   ::Screen* screen = DefaultScreenOfDisplay(display);
   int width = WidthOfScreen(screen);
   int height = HeightOfScreen(screen);
   return window_rect.size() == gfx::Size(width, height);
 #endif
 }
 
 bool IsMotionEvent(XEvent* event) {
   int type = event->type;
   if (type == GenericEvent)
     type = event->xgeneric.evtype;
   return type == MotionNotify;
 }
 
 int GetMappedButton(int button) {
   return XButtonMap::GetInstance()->GetMappedButton(button);
 }
 
 void UpdateButtonMap() {
   XButtonMap::GetInstance()->UpdateMapping();
 }
 
 void InitXKeyEventForTesting(EventType type,
                              KeyboardCode key_code,
                              int flags,
                              XEvent* event) {
   CHECK(event);
-  Display* display = GetXDisplay();
+  XDisplay* display = gfx::GetXDisplay();
   XKeyEvent key_event;
   key_event.type = XKeyEventType(type);
   CHECK_NE(0, key_event.type);
   key_event.serial = 0;
   key_event.send_event = 0;
   key_event.display = display;
   key_event.time = 0;
   key_event.window = 0;
   key_event.root = 0;
   key_event.subwindow = 0;
@@ skipping 29 matching lines @@
 }
 
 void XScopedImage::reset(XImage* image) {
   if (image_ == image)
     return;
   if (image_)
     XDestroyImage(image_);
   image_ = image;
 }
 
-XScopedCursor::XScopedCursor(::Cursor cursor, Display* display)
+XScopedCursor::XScopedCursor(::Cursor cursor, XDisplay* display)
     : cursor_(cursor),
       display_(display) {
 }
 
 XScopedCursor::~XScopedCursor() {
   reset(0U);
 }
 
 ::Cursor XScopedCursor::get() const {
   return cursor_;
 }
 
 void XScopedCursor::reset(::Cursor cursor) {
   if (cursor_)
     XFreeCursor(display_, cursor_);
   cursor_ = cursor;
 }
 
 // ----------------------------------------------------------------------------
 // These functions are declared in x11_util_internal.h because they require
 // XLib.h to be included, and it conflicts with many other headers.
-XRenderPictFormat* GetRenderARGB32Format(Display* dpy) {
+XRenderPictFormat* GetRenderARGB32Format(XDisplay* dpy) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   // First look for a 32-bit format which ignores the alpha value
   XRenderPictFormat templ;
   templ.depth = 32;
   templ.type = PictTypeDirect;
   templ.direct.red = 16;
   templ.direct.green = 8;
@@ skipping 15 matching lines @@
   if (!pictformat) {
     // Not all X servers support xRGB32 formats. However, the XRENDER spec says
     // that they must support an ARGB32 format, so we can always return that.
     pictformat = XRenderFindStandardFormat(dpy, PictStandardARGB32);
     CHECK(pictformat) << "XRENDER ARGB32 not supported.";
   }
 
   return pictformat;
 }
 
-XRenderPictFormat* GetRenderVisualFormat(Display* dpy, Visual* visual) {
+XRenderPictFormat* GetRenderVisualFormat(XDisplay* dpy, Visual* visual) {
   DCHECK(QueryRenderSupport(dpy));
 
   CachedPictFormats* formats = get_cached_pict_formats();
 
   for (CachedPictFormats::const_iterator i = formats->begin();
        i != formats->end(); ++i) {
     if (i->equals(dpy, visual))
       return i->format;
   }
 
@@ skipping 23 matching lines @@
   return pictformat;
 }
 
 void SetX11ErrorHandlers(XErrorHandler error_handler,
                          XIOErrorHandler io_error_handler) {
   XSetErrorHandler(error_handler ? error_handler : DefaultX11ErrorHandler);
   XSetIOErrorHandler(
       io_error_handler ? io_error_handler : DefaultX11IOErrorHandler);
 }
 
-void LogErrorEventDescription(Display* dpy,
+void LogErrorEventDescription(XDisplay* dpy,
                               const XErrorEvent& error_event) {
   char error_str[256];
   char request_str[256];
 
   XGetErrorText(dpy, error_event.error_code, error_str, sizeof(error_str));
 
   strncpy(request_str, "Unknown", sizeof(request_str));
   if (error_event.request_code < 128) {
     std::string num = base::UintToString(error_event.request_code);
     XGetErrorDatabaseText(
@@ skipping 26 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui