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

ui/base/x/x11_util.h

 // 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.
 
 #ifndef UI_BASE_X_X11_UTIL_H_
 #define UI_BASE_X_X11_UTIL_H_
 
 // This file declares utility functions for X11 (Linux only).
 //
 // These functions do not require the Xlib headers to be included (which is why
 // we use a void* for Visual*). The Xlib headers are highly polluting so we try
 // hard to limit their spread into the rest of the code.
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/event_types.h"
 #include "base/memory/ref_counted_memory.h"
 #include "ui/base/ui_export.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/x/x11_types.h"
 
 typedef unsigned long Atom;
-typedef unsigned long XID;
 typedef unsigned long XSharedMemoryId;  // ShmSeg in the X headers.
-typedef struct _XDisplay Display;
 typedef unsigned long Cursor;
 typedef struct _XcursorImage XcursorImage;
 typedef union _XEvent XEvent;
-typedef struct _XImage XImage;
-typedef struct _XGC *GC;
 
 #if defined(TOOLKIT_GTK)
 typedef struct _GdkDrawable GdkWindow;
 typedef struct _GtkWidget GtkWidget;
 typedef struct _GtkWindow GtkWindow;
 #endif
 
 namespace gfx {
 class Canvas;
 class Point;
 class Rect;
 }
 class SkBitmap;
 
 namespace ui {
 
 // These functions use the default display and this /must/ be called from
 // the UI thread. Thus, they don't support multiple displays.
 
 // These functions cache their results ---------------------------------
 
 // Check if there's an open connection to an X server.
 UI_EXPORT bool XDisplayExists();
 // Return an X11 connection for the current, primary display.
 
-// TODO(oshima|evan): This assume there is one display and dosn't work
-// undef mutiple displays/monitor environment. Remove this and change the
-// chrome codebase to get the display from window.
-UI_EXPORT Display* GetXDisplay();
-
 // X shared memory comes in three flavors:
 // 1) No SHM support,
 // 2) SHM putimage,
 // 3) SHM pixmaps + putimage.
 enum SharedMemorySupport {
   SHARED_MEMORY_NONE,
   SHARED_MEMORY_PUTIMAGE,
   SHARED_MEMORY_PIXMAP
 };
 // Return the shared memory type of our X connection.
-UI_EXPORT SharedMemorySupport QuerySharedMemorySupport(Display* dpy);
+UI_EXPORT SharedMemorySupport QuerySharedMemorySupport(XDisplay* dpy);
 
 // Return true iff the display supports Xrender
-UI_EXPORT bool QueryRenderSupport(Display* dpy);
+UI_EXPORT bool QueryRenderSupport(XDisplay* dpy);
 
 // Return the default screen number for the display
-int GetDefaultScreen(Display* display);
+int GetDefaultScreen(XDisplay* display);
 
 // Returns an X11 Cursor, sharable across the process.
 // |cursor_shape| is an X font cursor shape, see XCreateFontCursor().
 UI_EXPORT ::Cursor GetXCursor(int cursor_shape);
 
 // Resets the cache used by GetXCursor(). Only useful for tests that may delete
 // the display.
 UI_EXPORT void ResetXCursorCache();
 
 #if defined(USE_AURA)
@@ skipping 55 matching lines @@
 };
 // Sets _GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED on |window|.
 UI_EXPORT void SetHideTitlebarWhenMaximizedProperty(
     XID window,
     HideTitlebarWhenMaximized property);
 
 // Clears all regions of X11's default root window by filling black pixels.
 UI_EXPORT void ClearX11DefaultRootWindow();
 
 // Return the number of bits-per-pixel for a pixmap of the given depth
-UI_EXPORT int BitsPerPixelForPixmapDepth(Display* display, int depth);
+UI_EXPORT int BitsPerPixelForPixmapDepth(XDisplay* display, int depth);
 
 // Returns true if |window| is visible.
 UI_EXPORT bool IsWindowVisible(XID window);
 
 // Returns the bounds of |window|.
 UI_EXPORT bool GetWindowRect(XID window, gfx::Rect* rect);
 
 // Returns true if |window| contains the point |screen_loc|.
 UI_EXPORT bool WindowContainsPoint(XID window, gfx::Point screen_loc);
 
@@ skipping 38 matching lines @@
                                    const std::vector<int>& value);
 UI_EXPORT bool SetAtomArrayProperty(XID window,
                                     const std::string& name,
                                     const std::string& type,
                                     const std::vector<Atom>& value);
 
 // Gets the X atom for default display corresponding to atom_name.
 Atom GetAtom(const char* atom_name);
 
 // Sets the WM_CLASS attribute for a given X11 window.
-UI_EXPORT void SetWindowClassHint(Display* display,
+UI_EXPORT void SetWindowClassHint(XDisplay* display,
                                   XID window,
                                   std::string res_name,
                                   std::string res_class);
 
 // Get |window|'s parent window, or None if |window| is the root window.
 UI_EXPORT XID GetParentWindow(XID window);
 
 // Walk up |window|'s hierarchy until we find a direct child of |root|.
 XID GetHighestAncestorWindow(XID window, XID root);
 
 static const int kAllDesktops = -1;
 // Queries the desktop |window| is on, kAllDesktops if sticky. Returns false if
 // property not found.
 bool GetWindowDesktop(XID window, int* desktop);
 
 // Translates an X11 error code into a printable string.
-UI_EXPORT std::string GetX11ErrorString(Display* display, int err);
+UI_EXPORT std::string GetX11ErrorString(XDisplay* display, int err);
 
 // Implementers of this interface receive a notification for every X window of
 // the main display.
 class EnumerateWindowsDelegate {
  public:
   // |xid| is the X Window ID of the enumerated window.  Return true to stop
   // further iteration.
   virtual bool ShouldStopIterating(XID xid) = 0;
 
  protected:
@@ skipping 13 matching lines @@
 UI_EXPORT bool GetXWindowStack(XID window, std::vector<XID>* windows);
 
 // Restack a window in relation to one of its siblings.  If |above| is true,
 // |window| will be stacked directly above |sibling|; otherwise it will stacked
 // directly below it.  Both windows must be immediate children of the same
 // window.
 void RestackWindow(XID window, XID sibling, bool above);
 
 // Return a handle to a X ShmSeg. |shared_memory_key| is a SysV
 // IPC key. The shared memory region must contain 32-bit pixels.
-UI_EXPORT XSharedMemoryId AttachSharedMemory(Display* display,
+UI_EXPORT XSharedMemoryId AttachSharedMemory(XDisplay* display,
                                              int shared_memory_support);
-UI_EXPORT void DetachSharedMemory(Display* display, XSharedMemoryId shmseg);
+UI_EXPORT void DetachSharedMemory(XDisplay* display, XSharedMemoryId shmseg);
 
 // Copies |source_bounds| from |drawable| to |canvas| at offset |dest_offset|.
 // |source_bounds| is in physical pixels, while |dest_offset| is relative to
 // the canvas's scale. Note that this function is slow since it uses
 // XGetImage() to copy the data from the X server to this process before
 // copying it to |canvas|.
 UI_EXPORT bool CopyAreaToCanvas(XID drawable,
                                 gfx::Rect source_bounds,
                                 gfx::Point dest_offset,
                                 gfx::Canvas* canvas);
 
 // Return a handle to an XRender picture where |pixmap| is a handle to a
 // pixmap containing Skia ARGB data.
-UI_EXPORT XID CreatePictureFromSkiaPixmap(Display* display, XID pixmap);
+UI_EXPORT XID CreatePictureFromSkiaPixmap(XDisplay* display, XID pixmap);
 
 // Draws ARGB data on the given pixmap using the given GC, converting to the
 // server side visual depth as needed.  Destination is assumed to be the same
 // dimensions as |data| or larger.  |data| is also assumed to be in row order
 // with each line being exactly |width| * 4 bytes long.
-UI_EXPORT void PutARGBImage(Display* display,
+UI_EXPORT void PutARGBImage(XDisplay* display,
                             void* visual, int depth,
                             XID pixmap, void* pixmap_gc,
                             const uint8* data,
                             int width, int height);
 
 // Same as above only more general:
 // - |data_width| and |data_height| refer to the data image
 // - |src_x|, |src_y|, |copy_width| and |copy_height| define source region
 // - |dst_x|, |dst_y|, |copy_width| and |copy_height| define destination region
-UI_EXPORT void PutARGBImage(Display* display,
+UI_EXPORT 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);
 
-void FreePicture(Display* display, XID picture);
-void FreePixmap(Display* display, XID pixmap);
+void FreePicture(XDisplay* display, XID picture);
+void FreePixmap(XDisplay* display, XID pixmap);
 
 enum WindowManagerName {
   WM_UNKNOWN,
   WM_BLACKBOX,
   WM_CHROME_OS,
   WM_COMPIZ,
   WM_ENLIGHTENMENT,
   WM_ICE_WM,
   WM_KWIN,
   WM_METACITY,
@@ skipping 93 matching lines @@
   XImage* image_;
 
   DISALLOW_COPY_AND_ASSIGN(XScopedImage);
 };
 
 // Keeps track of a cursor returned by an X function and makes sure it's
 // XFreeCursor'd.
 class UI_EXPORT XScopedCursor {
  public:
   // Keeps track of |cursor| created with |display|.
-  XScopedCursor(::Cursor cursor, Display* display);
+  XScopedCursor(::Cursor cursor, XDisplay* display);
   ~XScopedCursor();
 
   ::Cursor get() const;
   void reset(::Cursor cursor);
 
  private:
   ::Cursor cursor_;
-  Display* display_;
+  XDisplay* display_;
 
   DISALLOW_COPY_AND_ASSIGN(XScopedCursor);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_X_X11_UTIL_H_