Remove X11/Xlib.h include from selection_requestor.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_base_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 XSharedMemoryId;  // ShmSeg in the X headers.
 typedef unsigned long Cursor;
 typedef struct _XcursorImage XcursorImage;
 typedef union _XEvent XEvent;
 
 namespace gfx {
 class Canvas;
 class Point;
 class Rect;
 }
@@ skipping 92 matching lines @@
 UI_BASE_EXPORT bool WindowContainsPoint(XID window, gfx::Point screen_loc);
 
 // Return true if |window| has any property with |property_name|.
 UI_BASE_EXPORT bool PropertyExists(XID window,
                                    const std::string& property_name);
 
 // Returns the raw bytes from a property with minimal
 // interpretation. |out_data| should be freed by XFree() after use.
 UI_BASE_EXPORT bool GetRawBytesOfProperty(
     XID window,
-    Atom property,
+    XAtom property,
     scoped_refptr<base::RefCountedMemory>* out_data,
     size_t* out_data_items,
-    Atom* out_type);
+    XAtom* out_type);
 
 // Get the value of an int, int array, atom array or string property.  On
 // success, true is returned and the value is stored in |value|.
 //
 // TODO(erg): Once we remove the gtk port and are 100% aura, all of these
-// should accept an Atom instead of a string.
+// should accept an XAtom instead of a string.
 UI_BASE_EXPORT bool GetIntProperty(XID window,
                                    const std::string& property_name,
                                    int* value);
 UI_BASE_EXPORT bool GetXIDProperty(XID window,
                                    const std::string& property_name,
                                    XID* value);
 UI_BASE_EXPORT bool GetIntArrayProperty(XID window,
                                         const std::string& property_name,
                                         std::vector<int>* value);
 UI_BASE_EXPORT bool GetAtomArrayProperty(XID window,
                                          const std::string& property_name,
-                                         std::vector<Atom>* value);
+                                         std::vector<XAtom>* value);
 UI_BASE_EXPORT bool GetStringProperty(XID window,
                                       const std::string& property_name,
                                       std::string* value);
 
 // These setters all make round trips.
 UI_BASE_EXPORT bool SetIntProperty(XID window,
                                    const std::string& name,
                                    const std::string& type,
                                    int value);
 UI_BASE_EXPORT bool SetIntArrayProperty(XID window,
                                         const std::string& name,
                                         const std::string& type,
                                         const std::vector<int>& value);
 UI_BASE_EXPORT bool SetAtomProperty(XID window,
                                     const std::string& name,
                                     const std::string& type,
-                                    Atom value);
+                                    XAtom value);
 UI_BASE_EXPORT bool SetAtomArrayProperty(XID window,
                                          const std::string& name,
                                          const std::string& type,
-                                         const std::vector<Atom>& value);
+                                         const std::vector<XAtom>& value);
 UI_BASE_EXPORT bool SetStringProperty(XID window,
-                                      Atom property,
-                                      Atom type,
+                                      XAtom property,
+                                      XAtom type,
                                       const std::string& value);
 
 // Gets the X atom for default display corresponding to atom_name.
-UI_BASE_EXPORT Atom GetAtom(const char* atom_name);
+UI_BASE_EXPORT XAtom GetAtom(const char* atom_name);
 
 // Sets the WM_CLASS attribute for a given X11 window.
 UI_BASE_EXPORT void SetWindowClassHint(XDisplay* display,
                                        XID window,
                                        const std::string& res_name,
                                        const std::string& res_class);
 
 // Sets the WM_WINDOW_ROLE attribute for a given X11 window.
 UI_BASE_EXPORT void SetWindowRole(XDisplay* display,
                                   XID window,
@@ skipping 66 matching lines @@
 
 // Enable the default X error handlers. These will log the error and abort
 // the process if called. Use SetX11ErrorHandlers() from x11_util_internal.h
 // to set your own error handlers.
 UI_BASE_EXPORT void SetDefaultX11ErrorHandlers();
 
 // Returns true if a given window is in full-screen mode.
 UI_BASE_EXPORT bool IsX11WindowFullScreen(XID window);
 
 // Returns true if the window manager supports the given hint.
-UI_BASE_EXPORT bool WmSupportsHint(Atom atom);
+UI_BASE_EXPORT bool WmSupportsHint(XAtom atom);
 
 // Manages a piece of X11 allocated memory as a RefCountedMemory segment. This
 // object takes ownership over the passed in memory and will free it with the
 // X11 allocator when done.
 class UI_BASE_EXPORT XRefcountedMemory : public base::RefCountedMemory {
  public:
   XRefcountedMemory(unsigned char* x11_data, size_t length)
       : x11_data_(length ? x11_data : NULL), length_(length) {}
 
   // Overridden from RefCountedMemory:
@@ skipping 67 matching lines @@
 UI_BASE_EXPORT void ResetXCursorCache();
 
 // Returns the cached XcursorImage for |cursor|.
 UI_BASE_EXPORT const XcursorImage* GetCachedXcursorImage(::Cursor cursor);
 
 }  // namespace test
 
 }  // namespace ui
 
 #endif  // UI_BASE_X_X11_UTIL_H_