Remove X11/Xlib.h include from selection_requestor.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 66 matching lines @@
 }
 
 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,
+                 XAtom* type, int* format, unsigned long* num_items,
                  unsigned char** property) {
-  Atom property_atom = GetAtom(property_name.c_str());
+  XAtom property_atom = GetAtom(property_name.c_str());
   unsigned long remaining_bytes = 0;
   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,
@@ skipping 376 matching lines @@
     unsigned long status;
   } MotifWmHints;
 
   MotifWmHints motif_hints;
   memset(&motif_hints, 0, sizeof(motif_hints));
   // Signals that the reader of the _MOTIF_WM_HINTS property should pay
   // attention to the value of |decorations|.
   motif_hints.flags = (1L << 1);
   motif_hints.decorations = use_os_window_frame ? 1 : 0;
 
-  ::Atom hint_atom = GetAtom("_MOTIF_WM_HINTS");
+  XAtom hint_atom = GetAtom("_MOTIF_WM_HINTS");
   XChangeProperty(gfx::GetXDisplay(),
                   window,
                   hint_atom,
                   hint_atom,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&motif_hints),
                   sizeof(MotifWmHints)/sizeof(long));
 }
 
@@ skipping 49 matching lines @@
 bool IsWindowVisible(XID window) {
   TRACE_EVENT0("ui", "IsWindowVisible");
 
   XWindowAttributes win_attributes;
   if (!XGetWindowAttributes(gfx::GetXDisplay(), window, &win_attributes))
     return false;
   if (win_attributes.map_state != IsViewable)
     return false;
 
   // Minimized windows are not visible.
-  std::vector<Atom> wm_states;
+  std::vector<XAtom> wm_states;
   if (GetAtomArrayProperty(window, "_NET_WM_STATE", &wm_states)) {
-    Atom hidden_atom = GetAtom("_NET_WM_STATE_HIDDEN");
+    XAtom hidden_atom = GetAtom("_NET_WM_STATE_HIDDEN");
     if (std::find(wm_states.begin(), wm_states.end(), hidden_atom) !=
             wm_states.end()) {
       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) ||
@@ skipping 87 matching lines @@
     }
     XFree(shape_rects);
     if (!is_in_shape_rects)
       return false;
   }
   return true;
 }
 
 
 bool PropertyExists(XID window, const std::string& property_name) {
-  Atom type = None;
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   XFree(property);
   return num_items > 0;
 }
 
 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) {
   // Retrieve the data from our window.
   unsigned long nitems = 0;
   unsigned long nbytes = 0;
-  Atom prop_type = None;
+  XAtom prop_type = None;
   int prop_format = 0;
   unsigned char* property_data = NULL;
   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)
@@ skipping 26 matching lines @@
   if (out_data_items)
     *out_data_items = nitems;
 
   if (out_type)
     *out_type = prop_type;
 
   return true;
 }
 
 bool GetIntProperty(XID window, const std::string& property_name, int* value) {
-  Atom type = None;
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   if (format != 32 || num_items != 1) {
     XFree(property);
     return false;
   }
 
   *value = static_cast<int>(*(reinterpret_cast<long*>(property)));
   XFree(property);
   return true;
 }
 
 bool GetXIDProperty(XID window, const std::string& property_name, XID* value) {
-  Atom type = None;
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1,
                            &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   if (format != 32 || num_items != 1) {
     XFree(property);
     return false;
   }
 
   *value = *(reinterpret_cast<XID*>(property));
   XFree(property);
   return true;
 }
 
 bool GetIntArrayProperty(XID window,
                          const std::string& property_name,
                          std::vector<int>* value) {
-  Atom type = None;
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
   if (result != Success)
     return false;
 
   if (format != 32) {
     XFree(properties);
     return false;
   }
 
   long* int_properties = reinterpret_cast<long*>(properties);
   value->clear();
   for (unsigned long i = 0; i < num_items; ++i) {
     value->push_back(static_cast<int>(int_properties[i]));
   }
   XFree(properties);
   return true;
 }
 
 bool GetAtomArrayProperty(XID window,
                           const std::string& property_name,
-                          std::vector<Atom>* value) {
-  Atom type = None;
+                          std::vector<XAtom>* value) {
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
 
   int result = GetProperty(window, property_name,
                            (~0L), // (all of them)
                            &type, &format, &num_items, &properties);
   if (result != Success)
     return false;
 
   if (type != XA_ATOM) {
     XFree(properties);
     return false;
   }
 
-  Atom* atom_properties = reinterpret_cast<Atom*>(properties);
+  XAtom* atom_properties = reinterpret_cast<XAtom*>(properties);
   value->clear();
   value->insert(value->begin(), atom_properties, atom_properties + num_items);
   XFree(properties);
   return true;
 }
 
 bool GetStringProperty(
     XID window, const std::string& property_name, std::string* value) {
-  Atom type = None;
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* property = NULL;
 
   int result = GetProperty(window, property_name, 1024,
                            &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   if (format != 8) {
@@ skipping 12 matching lines @@
                     int value) {
   std::vector<int> values(1, value);
   return SetIntArrayProperty(window, name, type, values);
 }
 
 bool SetIntArrayProperty(XID window,
                          const std::string& name,
                          const std::string& type,
                          const std::vector<int>& value) {
   DCHECK(!value.empty());
-  Atom name_atom = GetAtom(name.c_str());
-  Atom type_atom = GetAtom(type.c_str());
+  XAtom name_atom = GetAtom(name.c_str());
+  XAtom 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];
 
   gfx::X11ErrorTracker err_tracker;
   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 SetAtomProperty(XID window,
                      const std::string& name,
                      const std::string& type,
-                     Atom value) {
-  std::vector<Atom> values(1, value);
+                     XAtom value) {
+  std::vector<XAtom> values(1, value);
   return SetAtomArrayProperty(window, name, type, values);
 }
 
 bool SetAtomArrayProperty(XID window,
                           const std::string& name,
                           const std::string& type,
-                          const std::vector<Atom>& value) {
+                          const std::vector<XAtom>& value) {
   DCHECK(!value.empty());
-  Atom name_atom = GetAtom(name.c_str());
-  Atom type_atom = GetAtom(type.c_str());
+  XAtom name_atom = GetAtom(name.c_str());
+  XAtom type_atom = GetAtom(type.c_str());
 
   // XChangeProperty() expects values of type 32 to be longs.
-  scoped_ptr<Atom[]> data(new Atom[value.size()]);
+  scoped_ptr<XAtom[]> data(new XAtom[value.size()]);
   for (size_t i = 0; i < value.size(); ++i)
     data[i] = value[i];
 
   gfx::X11ErrorTracker err_tracker;
   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 SetStringProperty(XID window,
-                       Atom property,
-                       Atom type,
+                       XAtom property,
+                       XAtom type,
                        const std::string& value) {
   gfx::X11ErrorTracker err_tracker;
   XChangeProperty(gfx::GetXDisplay(),
                   window,
                   property,
                   type,
                   8,
                   PropModeReplace,
                   reinterpret_cast<const unsigned char*>(value.c_str()),
                   value.size());
   return !err_tracker.FoundNewError();
 }
 
-Atom GetAtom(const char* name) {
+XAtom GetAtom(const char* name) {
   // TODO(derat): Cache atoms to avoid round-trips to the server.
   return XInternAtom(gfx::GetXDisplay(), name, false);
 }
 
 void SetWindowClassHint(XDisplay* display,
                         XID window,
                         const std::string& res_name,
                         const std::string& res_class) {
   XClassHint class_hints;
   // const_cast is safe because XSetClassHint does not modify the strings.
@@ skipping 275 matching lines @@
 }
 
 void SetDefaultX11ErrorHandlers() {
   SetX11ErrorHandlers(NULL, NULL);
 }
 
 bool IsX11WindowFullScreen(XID window) {
   // If _NET_WM_STATE_FULLSCREEN is in _NET_SUPPORTED, use the presence or
   // absence of _NET_WM_STATE_FULLSCREEN in _NET_WM_STATE to determine
   // whether we're fullscreen.
-  Atom fullscreen_atom = GetAtom("_NET_WM_STATE_FULLSCREEN");
+  XAtom fullscreen_atom = GetAtom("_NET_WM_STATE_FULLSCREEN");
   if (WmSupportsHint(fullscreen_atom)) {
-    std::vector<Atom> atom_properties;
+    std::vector<XAtom> atom_properties;
     if (GetAtomArrayProperty(window,
                              "_NET_WM_STATE",
                              &atom_properties)) {
       return std::find(atom_properties.begin(),
                        atom_properties.end(),
                        fullscreen_atom) !=
           atom_properties.end();
     }
   }
 
   gfx::Rect window_rect;
   if (!ui::GetWindowRect(window, &window_rect))
     return false;
 
   // 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.
   ::XDisplay* display = gfx::GetXDisplay();
   ::Screen* screen = DefaultScreenOfDisplay(display);
   int width = WidthOfScreen(screen);
   int height = HeightOfScreen(screen);
   return window_rect.size() == gfx::Size(width, height);
 }
 
-bool WmSupportsHint(Atom atom) {
-  std::vector<Atom> supported_atoms;
+bool WmSupportsHint(XAtom atom) {
+  std::vector<XAtom> supported_atoms;
   if (!GetAtomArrayProperty(GetX11RootWindow(),
                             "_NET_SUPPORTED",
                             &supported_atoms)) {
     return false;
   }
 
   return std::find(supported_atoms.begin(), supported_atoms.end(), atom) !=
       supported_atoms.end();
 }
 
@@ skipping 142 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