Move ui::GetAtom to gfx::GetAtom

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 76 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,
                  XAtom* type, int* format, unsigned long* num_items,
                  unsigned char** property) {
-  XAtom property_atom = GetAtom(property_name.c_str());
+  XAtom property_atom = gfx::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 327 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;
 
-  XAtom hint_atom = GetAtom("_MOTIF_WM_HINTS");
+  XAtom hint_atom = gfx::GetAtom("_MOTIF_WM_HINTS");
   XChangeProperty(gfx::GetXDisplay(),
                   window,
                   hint_atom,
                   hint_atom,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&motif_hints),
                   sizeof(MotifWmHints)/sizeof(long));
 }
 
 bool IsShapeExtensionAvailable() {
   int dummy;
   static bool is_shape_available =
       XShapeQueryExtension(gfx::GetXDisplay(), &dummy, &dummy);
   return is_shape_available;
 }
 
 XID GetX11RootWindow() {
   return DefaultRootWindow(gfx::GetXDisplay());
 }
 
 bool GetCurrentDesktop(int* desktop) {
   return GetIntProperty(GetX11RootWindow(), "_NET_CURRENT_DESKTOP", desktop);
 }
 
 void SetHideTitlebarWhenMaximizedProperty(XID window,
                                           HideTitlebarWhenMaximized property) {
   // XChangeProperty() expects "hide" to be long.
   unsigned long hide = property;
-  XChangeProperty(gfx::GetXDisplay(),
-      window,
-      GetAtom("_GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"),
-      XA_CARDINAL,
-      32,  // size in bits
-      PropModeReplace,
-      reinterpret_cast<unsigned char*>(&hide),
-      1);
+  XChangeProperty(gfx::GetXDisplay(), window,
+                  gfx::GetAtom("_GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED"),
+                  XA_CARDINAL,
+                  32,  // size in bits
+                  PropModeReplace, reinterpret_cast<unsigned char*>(&hide), 1);
 }
 
 void ClearX11DefaultRootWindow() {
   XDisplay* display = gfx::GetXDisplay();
   XID root_window = GetX11RootWindow();
   gfx::Rect root_bounds;
   if (!GetOuterWindowBounds(root_window, &root_bounds)) {
     LOG(ERROR) << "Failed to get the bounds of the X11 root window";
     return;
   }
@@ skipping 14 matching lines @@
 
   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<XAtom> wm_states;
   if (GetAtomArrayProperty(window, "_NET_WM_STATE", &wm_states)) {
-    XAtom hidden_atom = GetAtom("_NET_WM_STATE_HIDDEN");
+    XAtom hidden_atom = gfx::GetAtom("_NET_WM_STATE_HIDDEN");
     if (base::ContainsValue(wm_states, hidden_atom))
       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 ||
@@ skipping 290 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());
-  XAtom name_atom = GetAtom(name.c_str());
-  XAtom type_atom = GetAtom(type.c_str());
+  XAtom name_atom = gfx::GetAtom(name.c_str());
+  XAtom type_atom = gfx::GetAtom(type.c_str());
 
   // XChangeProperty() expects values of type 32 to be longs.
   std::unique_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,
@@ skipping 11 matching lines @@
                      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<XAtom>& value) {
   DCHECK(!value.empty());
-  XAtom name_atom = GetAtom(name.c_str());
-  XAtom type_atom = GetAtom(type.c_str());
+  XAtom name_atom = gfx::GetAtom(name.c_str());
+  XAtom type_atom = gfx::GetAtom(type.c_str());
 
   // XChangeProperty() expects values of type 32 to be longs.
   std::unique_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,
@@ skipping 14 matching lines @@
                   window,
                   property,
                   type,
                   8,
                   PropModeReplace,
                   reinterpret_cast<const unsigned char*>(value.c_str()),
                   value.size());
   return !err_tracker.FoundNewError();
 }
 
-XAtom GetAtom(const char* name) {
-  return X11AtomCache::GetInstance()->GetAtom(name);
-}
-
 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.
   // 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);
 }
 
 void SetWindowRole(XDisplay* display, XID window, const std::string& role) {
   if (role.empty()) {
-    XDeleteProperty(display, window, GetAtom("WM_WINDOW_ROLE"));
+    XDeleteProperty(display, window, gfx::GetAtom("WM_WINDOW_ROLE"));
   } else {
     char* role_c = const_cast<char*>(role.c_str());
-    XChangeProperty(display, window, GetAtom("WM_WINDOW_ROLE"), XA_STRING, 8,
-                    PropModeReplace,
-                    reinterpret_cast<unsigned char*>(role_c),
-                    role.size());
+    XChangeProperty(display, window, gfx::GetAtom("WM_WINDOW_ROLE"), XA_STRING,
+                    8, PropModeReplace,
+                    reinterpret_cast<unsigned char*>(role_c), role.size());
   }
 }
 
 bool GetCustomFramePrefDefault() {
   // If the window manager doesn't support enough of EWMH to tell us its name,
   // assume that it doesn't want custom frames. For example, _NET_WM_MOVERESIZE
   // is needed for frame-drag-initiated window movement.
   std::string wm_name;
   if (!GetWindowManagerName(&wm_name))
     return false;
@@ skipping 245 matching lines @@
 
 std::string GuessWindowManagerName() {
   std::string name;
   if (GetWindowManagerName(&name))
     return name;
   return "Unknown";
 }
 
 bool IsCompositingManagerPresent() {
   static bool is_compositing_manager_present =
-      XGetSelectionOwner(gfx::GetXDisplay(), GetAtom("_NET_WM_CM_S0")) != None;
+      XGetSelectionOwner(gfx::GetXDisplay(), gfx::GetAtom("_NET_WM_CM_S0")) !=
+      None;
   return is_compositing_manager_present;
 }
 
 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.
-  XAtom fullscreen_atom = GetAtom("_NET_WM_STATE_FULLSCREEN");
+  XAtom fullscreen_atom = gfx::GetAtom("_NET_WM_STATE_FULLSCREEN");
   if (WmSupportsHint(fullscreen_atom)) {
     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();
     }
@@ skipping 173 matching lines @@
       using_software_rendering_(false),
       have_gpu_argb_visual_(false) {
   int visuals_len = 0;
   XVisualInfo visual_template;
   visual_template.screen = DefaultScreen(display_);
   gfx::XScopedPtr<XVisualInfo[]> visual_list(XGetVisualInfo(
       display_, VisualScreenMask, &visual_template, &visuals_len));
   for (int i = 0; i < visuals_len; ++i)
     visuals_[visual_list[i].visualid].reset(new XVisualData(visual_list[i]));
 
-  XAtom NET_WM_CM_S0 = GetAtom("_NET_WM_CM_S0");
+  XAtom NET_WM_CM_S0 = gfx::GetAtom("_NET_WM_CM_S0");
   using_compositing_wm_ = XGetSelectionOwner(display_, NET_WM_CM_S0) != None;
 
   // Choose the opaque visual.
   default_visual_id_ =
       XVisualIDFromVisual(DefaultVisual(display_, DefaultScreen(display_)));
   system_visual_id_ = default_visual_id_;
   DCHECK(system_visual_id_);
   DCHECK(visuals_.find(system_visual_id_) != visuals_.end());
 
   // Choose the transparent visual.
@@ skipping 76 matching lines @@
                                 visual_info.visual, AllocNone);
   }
   return colormap_;
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui