Remove usages of XInternAtom

ui/platform_window/x11/x11_window_base.cc

 // Copyright 2016 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.
 
 #include "ui/platform_window/x11/x11_window_base.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include <string>
 
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/platform_window_defaults.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/base/x/x11_window_event_manager.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/platform_window/platform_window_delegate.h"
 
 namespace ui {
 
 namespace {
 
-const char* kAtomsToCache[] = {"UTF8_STRING",  "WM_DELETE_WINDOW",
-                               "_NET_WM_NAME", "_NET_WM_PID",
-                               "_NET_WM_PING", NULL};
-
 XID FindXEventTarget(const XEvent& xev) {
   XID target = xev.xany.window;
   if (xev.type == GenericEvent)
     target = static_cast<XIDeviceEvent*>(xev.xcookie.data)->event;
   return target;
 }
 
 }  // namespace
 
 X11WindowBase::X11WindowBase(PlatformWindowDelegate* delegate,
                              const gfx::Rect& bounds)
     : delegate_(delegate),
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(None),
       xroot_window_(DefaultRootWindow(xdisplay_)),
-      atom_cache_(xdisplay_, kAtomsToCache),
       bounds_(bounds) {
   DCHECK(delegate_);
   TouchFactory::SetTouchDeviceListFromCommandLine();
 }
 
 X11WindowBase::~X11WindowBase() {
   Destroy();
 }
 
 void X11WindowBase::Destroy() {
@@ skipping 50 matching lines @@
   XISetMask(mask, XI_HierarchyChanged);
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(xdisplay_, xwindow_, &evmask, 1);
   XFlush(xdisplay_);
 
   ::Atom protocols[2];
-  protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
-  protocols[1] = atom_cache_.GetAtom("_NET_WM_PING");
+  protocols[0] = GetAtom("WM_DELETE_WINDOW");
+  protocols[1] = GetAtom("_NET_WM_PING");
   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 
   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
   // the desktop environment.
   XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 
   // Likewise, the X server needs to know this window's pid so it knows which
   // program to kill if the window hangs.
   // XChangeProperty() expects "pid" to be long.
   static_assert(sizeof(long) >= sizeof(pid_t),
                 "pid_t should not be larger than long");
   long pid = getpid();
-  XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("_NET_WM_PID"),
-                  XA_CARDINAL, 32, PropModeReplace,
-                  reinterpret_cast<unsigned char*>(&pid), 1);
+  XChangeProperty(xdisplay_, xwindow_, GetAtom("_NET_WM_PID"), XA_CARDINAL, 32,
+                  PropModeReplace, reinterpret_cast<unsigned char*>(&pid), 1);
   // Before we map the window, set size hints. Otherwise, some window managers
   // will ignore toplevel XMoveWindow commands.
   XSizeHints size_hints;
   size_hints.flags = PPosition | PWinGravity;
   size_hints.x = bounds_.x();
   size_hints.y = bounds_.y();
   // Set StaticGravity so that the window position is not affected by the
   // frame width when running with window manager.
   size_hints.win_gravity = StaticGravity;
   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
@@ skipping 65 matching lines @@
 
 gfx::Rect X11WindowBase::GetBounds() {
   return bounds_;
 }
 
 void X11WindowBase::SetTitle(const base::string16& title) {
   if (window_title_ == title)
     return;
   window_title_ = title;
   std::string utf8str = base::UTF16ToUTF8(title);
-  XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("_NET_WM_NAME"),
-                  atom_cache_.GetAtom("UTF8_STRING"), 8, PropModeReplace,
+  XChangeProperty(xdisplay_, xwindow_, GetAtom("_NET_WM_NAME"),
+                  GetAtom("UTF8_STRING"), 8, PropModeReplace,
                   reinterpret_cast<const unsigned char*>(utf8str.c_str()),
                   utf8str.size());
   XTextProperty xtp;
   char* c_utf8_str = const_cast<char*>(utf8str.c_str());
   if (Xutf8TextListToTextProperty(xdisplay_, &c_utf8_str, 1, XUTF8StringStyle,
                                   &xtp) == Success) {
     XSetWMName(xdisplay_, xwindow_, &xtp);
     XFree(xtp.value);
   }
 }
@@ skipping 57 matching lines @@
                        xev->xconfigure.width, xev->xconfigure.height);
       if (bounds_ != bounds) {
         bounds_ = bounds;
         delegate_->OnBoundsChanged(bounds_);
       }
       break;
     }
 
     case ClientMessage: {
       Atom message = static_cast<Atom>(xev->xclient.data.l[0]);
-      if (message == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
+      if (message == GetAtom("WM_DELETE_WINDOW")) {
         delegate_->OnCloseRequest();
-      } else if (message == atom_cache_.GetAtom("_NET_WM_PING")) {
+      } else if (message == GetAtom("_NET_WM_PING")) {
         XEvent reply_event = *xev;
         reply_event.xclient.window = xroot_window_;
 
         XSendEvent(xdisplay_, reply_event.xclient.window, False,
                    SubstructureRedirectMask | SubstructureNotifyMask,
                    &reply_event);
         XFlush(xdisplay_);
       }
       break;
     }
   }
 }
 
 }  // namespace ui